Scream very loudly

Question

Write a script that outputs A to stdout infinitely.

There should be no newlines or separators between the characters.

Standard loopholes apply.

This is code-golf. The shortest solution in each language wins.

Answer 1

Kenbark-1 (first personal computer) 6/7 bytes

002:
024 X 
004 PC
234 200 Print A from X
343 004 jump back to begin of the program

Register X is on Address 002 (oct) Then we set program Counter (address 003) to 004 for starting code. Move value from X (024='A') to output register what is set of lights on device front (Address 200 oct). And unconditional jump back to address 004.

User will see steady light, but in reality computer still output A

I'm not sure how to count bytes since that 002: is needed to tell computer what part of memory we need to fill.

Try it by yourself: http://www.neocomputer.org/kenbak/kenbak1-JS.html

Answer 2

C# (Visual C# Interactive Compiler), 21 18 bytes

for(;;)Write('A');

Try it online!

Answer 3

JavaScript (Node.js), 33 32 bytes

for(;;)process.stdout.write('A')

Try it online!

-1 byte thanks to Maria Miller

Answer 4

ColdFusion, 32 bytes

<cfloop condition="1">A</cfloop>

Answer 5

*><>, 4 bytes

"A"o

Try it online!

Pushes A then prints it an infinite amount of times

Answer 6

Ahead, 5 bytes

~oA'~

Try it online!

Answer 7

Brachylog, 4 bytes

Ṇhw↰

Try it online!

Answer 8

Brainetry --live-output, 59 bytes

This uses the --live-output flag otherwise output would be deferred until the end of the program, which would never happen because the program doesn't end.

a b c d e f
a b c d e f g h
a b c d e f g
a b c d e f g h i

Golfed version of the following code:

This program will ask you for
some input but I really only care about
the first character of input. I'm gonna
take such a character and output it MANY times.

To try this, clone this GH repo and run python brainetry.py btry/scream.btry and give it A as input.

Answer 9

FEU, 18 bytes

a/A
loop
print
end

Try it online!

Explanation

a/A

Append A to the empty input.

loop
print
end

Starts an infinite loop where you print the input.

Answer 10

Scala, 20 bytes

while(print('A')!=0)

Answer 11

CJam, 7 bytes

'A{_o}h

CJam loops are surprisingly expensive as there are no markers, and since there's no infinite loop function, we need to make sure there's always a spare truthy A on the stack for our do-while loop.

Try it online

Explanation:

'A        Push 'A' to the stack
  {  }h   Loop while top of stack is true
   _      Duplicate the A
    o     Pop and output the A w/ no newline

Answer 12

Oak, 29 Bytes

fn main(){while(1){prc!(65)}}

This may have to be changed to fn main(){while(1){prc!('A')}} once num and char are no longer interchangable, but for now it works.

Answer 13

Perl 6, 16 bytes

loop {print "A"}

Try it online!

Answer 14

Neim, 5 bytes

ͻ    # Infinite loop
 (   # Decompress base 255
  A  # A
 )   #
   B # Compress number to base 255

Runs only 6 times

Try It Online!

Answer 15

x86 machine code - 14 bytes

So, yeah I'm using write() system call to print A characters without \n

     6                                  scream:
     7 00000000 6A41                      push 0x41
     8 00000002 31DB                      xor ebx, ebx
     9 00000004 89E1                      mov ecx, esp 
    10 00000006 B201                      mov dl, 0x1 
    11 00000008 B004                      mov al, 0x4 
    12 0000000A CD80                      int 0x80
    13 0000000C EBF2                      jmp scream

This is output using strace :

write(0, "A", 1A)                        = 1
write(0, "A", 1A)                        = 1
write(0, "A", 1A)                        = 1
write(0, "A", 1A)                        = 1
<repeat> ..

Answer 16

StupidStackLanguage, 11 bytes

avqviiimtfu

Try it online!

Explanation

a - push 0 to stack
v - add 5
q - duplicate
viii - add 8 (making 13)
m - multiply top 2 items (13x5 = 65)
t - start bf style loop
f - print character
u - end bf style loop

Answer 17

Husk, 3 bytes

∞'A

Try it online! Creates an infinite list of 'A characters and prints it.

Answer 18

C#, 62 bytes

class P{static void Main(){for(;;)System.Console.Write('A');}}

Answer 19

Deadfish~, 4014 bytes:

{iiiiii}iiiii{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{c}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}}

Sets the accumulator to 65, then prints as character 10²⁰⁰⁰ times = far beyond the lifespan of the universe.

There's no way to do anything infinitely in Deadfish~, so 10²⁰⁰⁰ times should be enough.

Answer 20

VBScript, 31 bytes

Do 
WScript.StdOut.Write("A")
Loop

Answer 21

C# 9, 33

for(;;)System.Console.Write('A');

Answer 22

Barrel, 9 bytes (or 8 with newer instruction)

^A¤p←1

Explanation:

^A     // Sets the accumulator to the ASCII codepoint of 'A'.
  ¤ ←1 // Creates a jump target and jumps back to it.
   p   // Prints the accumulator as a character value.

Since the ← command will implicitly push the current location onto the location pointer stack, this program will use lots of system memory. In fact, on my system it used about one megabyte of RAM per second. To overcome this, I've since implemented the ↰ operator, which jumps without pushing (and therefore removes the possibility of RAM overflow). It makes the command look like this: ^A¤p↰1

This could be 8 bytes now that I have implemented the infinite loop that I'd thought about implementing: ^65#∞p In this case, the #∞p would define a loop which would print the character value infinitely. However, since the infinity command may have been inspired by this (I actually forget) and the command is newer than the answer anyway, I'll refrain from changing my answer.

Answer 23

Ruby, 12 bytes

loop{$><<?A}

Try it online!

---

Explanation

loop {...} //infinite loop
$> //synonym for STDOUT
<<?A // << appends an element and ?A is shorthand for 'A'

Answer 24

Mascarpone, 11 bytes

['A.:!]v*:!
[   :!]v*:!  // infinite loop
 'A.         // with the side effect of outputting 'A' each iteration

I feel a bit scummy for reposting the same code to multiple questions, but I guess it has to be done.

Answer 25

Nim, 26, 25 bytes (Credits to @hyper-neutrino)

while 1>0:stdout.write'A'

Try it online!

Not great, but not too shabby.

Answer 26

Daoyu, 13 instructions, 7 bytes

There's two! Each instruction is a hex, so two instructions fit in a byte.

$$$(([]!)/(/[]!)):><
OPLEV 0:
$$$                   Allocate 8 bits of memory to the bit tape
   (([]!)/(/[]!))     Set the bit tape to 01000001
                 :><  Print the bit tape, and loop to the beginning
OPLEV 1:
...                   NOP
   ((().)/(/().))     Moves around the bit tape with no effect
                 :><  Print the bit tape, and loop to the beginning

This one is simpler, but it's 20 instructions and an extra byte. The first time the program loops, the operation level is 0, and it runs the first program, which allocates memory, sets the bit tape to 'A', and prints. Every other time it loops it just prints the bit tape.

%!)))):((((><
%!             Acts as NOP, encodes 'A'
  ))))         Moves data reader to '%!'/'A'
      :((((><  Prints, resets position, and loops to beginning

This one reads its own source code, and is a few bytes smaller. The operation level does change, but it doesn't really affect any of the program. When attempting to MERGE ()) while selecting the entire but tape, which is the original state of the program, the data reader moves to the parent bit tape, which is the program's source code. The program navigates to the %!, prints it as 'A', and loops.

Answer 27

Deorst, 6 bytes

oA
#EO

Try it online!

Explanation:

oA   # Push 'A'
#    # Forever:
 EO  #   Print without newline

Answer 28

WedgeScript, 4 bytes

'A|o

Explanation:

'A    Pushes the character literal A to the stack\
|     Loop the rest of the code infinitely\
o     Output

Yes, Wedgescript is a custom language made by me, here is the repo with interpreter install instructions: https://github.com/WedgeScript/WedgeScript

Answer 29

Japt, 10 bytes

{Oo'A}g1/0

Try it online!

Explanation

{Oo'A}a
{          // Function
 Oo'A      //    Output 'A'
     }     // End Function
      g1/0 // Call infinite times
           // (Japt's O.o() method returns undefined)

---

Japt, 7 bytes

As pointed out by @Shaggy due to how a is implemented this will print A only 1e8 times

{Oo'A}a

Try it online!

Explanation

{Oo'A}a
{       // Function
 Oo'A   //    Output 'A'
     }  // End Function
      a // Call repeatedly until it returns a truthy value
        // (Japt's O.o() method returns undefined)

Answer 30

Arduino, 63 bytes

void setup(){Serial.begin(300);}void loop(){Serial.write('A');}

Not sure how much explaining I need to do here. Arduino has an infinite loop built-in, so just write one 'A' to the Serial output inside of it. Equally valid would be Serial.print('A'); and Serial.print("A");, and I think Serial.write("A"); should work as well. It's all just a matter of preference.