05AB1E, 4 bytes (chunk size 2 or 4)

·Inr

Try it online or doubled as a single 4-byte chunk or doubled as two 2-byte chunks.

· # double the implicit input
 In # square the input
 r # reverse the stack
 # stack is now [input ** 2, input * 2]
 # if we stop here, the top (input * 2) is implicitly outputted
· # double the top of the stack (giving 4 * input, not that it matters)
 In # square the input
 r # reverse the stack, putting the first
 # stack is now [input ** 2, input * 4, input ** 2]
 # input ** 2 is implicitly outputted

Perl 5, 8 bytes (chunk size 4)

$_*=~~+2

Try it online, or try the doubled version.

Unary ~ is the bitwise negate, so applying it twice is a noop. Thus, the base program simply multiplies $_ (the implicit input-output variable) by 2.

Binary ~~ is smartmatch, which returns a boolean. ~~+2~~+2 parses as (~~+2) ~~ (+2). Since 2 equals 2, this yields true (1). Thus, the doubled program first multiplies $_ by 1, then multiplies $_ by itself.

Befunge-98 (FBBI), 8 bytes (chunk length 2)

;&:#* +q

Try it online!

;&;&:#:#* * +q+q

Try it online! (doubled)

Excluding control flow, the first program executes &:+q (input, duplicate top of stack, add, exit with return code), and the second executes &:*+q (input, duplicate top of stack, multiply, add (sums with an implicit 0), exit with return code)

Python 3, 32 30 28 bytes (chunk size 16 15 14)

lambda n:bool(0)*n*n or 2*n

Try it online!

-4 bytes thanks to @negativeSeven

Doubled:

lambda n:bool(lambda n:bool(0)*n*n or 2*n0)*n*n or 2*n

Try it online!

The function takes advantage of the unique chunk rule of this challenge.

JavaScript (ES6),  24  22 bytes

Despite its unusual format, this is the definition of an anonymous function, which can be either called directly or assigned to a variable.

+(g=x=>x*x)?g:(x=>x*2)

Try it online!

+(g=x=>x*x)?g:(x=>x*2)+(g=x=>x*x)?g:(x=>x*2)

Try it online doubled!

How?

Applying the unary + to a function is interpreted as an attempt to coerce it to a number and results in NaN. Therefore, the leading +(g=x=>x*x) is falsy in both versions.

On the other hand, applying the binary + between 2 functions results in a string. Therefore, (x=>x*2)+(g=x=>x*x) is truthy in the doubled version.

Runic Enchantments, 9 bytes (chunk size 3)

i3?:*@:+@

Try it online!
Try it doubled!

The 3? skips the next 3 instructions, resulting in an (executed) i3?...:+@. When doubled it results in an executed i3?...:*@ where . represents the 3 NOP'd instructions. @ is "print entire stack and terminate."

Charcoal, 13 bytes

ＰＩ×Ｉθ⎇υＩθ²⊞υω

Try it online! Explanation: The predefined empty list is falsey so the input is multiplied by 2. When doubled the second pass sees the empty string has been pushed to the list so it multiplies the input by itself instead. Try it online! In verbose syntax this corresponds to Multiprint(Cast(Times(Cast(q), Ternary(u, Cast(q), 2)))); Push(u, w);.

R, 59 bytes (chunk size 59)

c(`*`,`^`)[[1+length(readLines())]](scan(file("stdin")),2)

Try it online!

Note the trailing newline. This forces scan to read from stdin rather than the source file (which is what stdin() redirects to....), and use readLines() to ignore all additional copies of the source, inspired by this answer to a similar challenge.

This isn't particularly interesting, but doubtless something clever manipulating the chunk size will be dreamed up.

Japt, 7 5 bytes

*N²jJ

Try it | Doubled

² pushes 2 to the array of inputs N then j removes & returns the element at index J=-1 (i.e., the newly inserted 2) and multiplies the input by that.

When doubled it results in J being multiplied by 2, so the element at index -2 (i.e., the input) is returned by j and used as the multiplier.

C# (Visual C# Interactive Compiler) / Javascript, 22 bytes, chunk size 11

m=>/* /2*m//*/m*2

Try it online!

Perl 6, 8 bytes (chunk size 1)

* *<1 2>

Try it online! Try it doubled!

A Whatever/HyperWhatever lambda that takes a number and returns a number for the first program and a singleton list for the second program. Basically this keeps the exact same logic, except that the multiplication operator (*) is replaced by the exponential one (**).

The Whatever literal (confusingly also represented by a *) are doubled up to a HyperWhatever (**) which is basically the same except it maps over lists. The space is needed to separate the Whatever literal from the multiplication and is ignored when doubled up. Instead of just 2 (which would get doubled to 22) we use a list containing two elements, which evaluates to 2 in a numeric context). The <> can be doubled to a list with interpolation, and the two elements inside are doubled, but neither of those change the length of the list.

Brain-Flak (BrainHack), 76 bytes, 76 byte chunks

(<>)(()[([][()])](<(()([()])<>)<>>))(()()<>)(<>)<>

Try it online!

Doubled (with newline for clarity)

(<>)(()[([][()])](<(()([()])<>)<>>))(()()<>)(<>)<>
(<>)(()[([][()])](<(()([()])<>)<>>))(()()<>)(<>)<>

Try it online!

Here is a version that uses a more complex doubling procedure. It does 5 chunks of size 15. The code here is 46 bytes however due to the required padding it is substantially longer.

105 bytes, 15 byte chunks

( <>< <>>()([()])<><(()())><> )<> 

Try it online!

Doubled (with newlines for clarity)

( ( 
 
<>< <>< 
<>>()([()])<>>()([()])
<><(()())><> <><(()())><> 
 
)<> )<> 

Try it online!

Perl 5 (-p), 22 15 bytes

-7 bytes thanks to Grimy

$_*=$'/4||2;//;

TIO

Python 3, 56 53 bytes

print(eval(input()+"**2"[len(*open(__file__))%2:])) #

My python skills kinda suck, so can definitely be golfed.. Based on the Python answer in the "I double the source, you double the output!" challenge.

Chunk length 53.

Try it online or try it online doubled.

Java 8, 62 bytes

n->n*(Byte.SIZE>8?n:2);/*
class Bytestatic int SIZE=9;/**///

Chunk length 62.

Try it online or try it online doubled.

Explanation:

n-> // Method with integer as both parameter and return-type
 n* // The input, multiplied by:
 (Byte.SIZE>8? // If Byte.SIZE is larger than 8:
 n // Multiply by the input itself
 : // Else:
 2); // Multiply by 2
class Byte // Class which overwrites Byte
 static int SIZE=9; // And sets the SIZE to 9

In Java, the available comments are // comment and /* comment */. Which are combined here to overwrite certain parts. See how these comments work thanks to the Java highlighting:

n->n*(Byte.SIZE>8?n:2);/*
class Bytestatic int SIZE=9;/**///

n->n*(Byte.SIZE>8?n:2);/*
class Bytestatic int SIZE=9;/**///n->n*(Byte.SIZE>8?n:2);/*
class Bytestatic int SIZE=9;/**///

The doubled program created a custom Byte class and its value SIZE=9, which overwrites the default java.lang.Byte class and its value SIZE=8.

Jelly, 8 6 bytes (chunk length 3)

Ḥ;²3ị 

Try it online!

Doubled

J, 17 bytes

*:@[`(+:@[)@.(=~)

Try it online!

Doubled version: Try it online!

In the single version, we have a single verb which uses Agenda @. to do the if... then logic: If the argument is equal to itself =~, then take the argument and double it (+:@[).

However, when we double the code, we get a J hook. Call the verb f and the input y. Then the hook f f executes like this:

y f (f y)

Which means that now the original input is the left arg, and the right arg is the doubled input. Since these will not be equal, =~ will return false this time, and now we'll execute the other fork of the Agenda, ie, *:@[, which means "square the left arg." And since that's the original input, we have what we need.