[Question]
  [
With roughly one second (plus or minus 10 ms) between outputs, output anything.  
The first output must be at most one second after the start of the program, but can be as soon as right when the program starts.  
So, the first output can be up to a second after the program starts, the second exactly one second after that, the third a second after that, and so on to infinity.
The outputs do not need to be consistent, nor have any sort of delimiter. However, they must be visible (even if it's only visible when highlighted).
  
[Answer]
# MacOS shell, 3
```
top
```
On the Mac, `top`'s default refresh period is 1 sec.
---
# Linux shell, 7
```
top -d1
```
Unfortunately on Linux, `top`'s default refresh period is more like 2 secs, so we need an extra 4 bytes.
Since this is just one command, both variants are shell-agnostic.
[Answer]
# [Bash](https://www.gnu.org/software/bash/) + `iputils`, 6 bytes
```
ping 0
```
send `ICMP ECHO_REQUEST` to 0 (127.0.0.1) once per second.
---
# [Bash](https://www.gnu.org/software/bash/) + `procps-ng`, 8 bytes
```
free -s1
```
Display amount of free and used memory in the system with one second between outputs.
[Answer]
# [Python 3](https://docs.python.org/3/), ~~40~~ 39 bytes
```
import time
while[help()]:time.sleep(1)
```
[Try it online!](https://tio.run/##K6gsycjPM/7/PzO3IL@oRKEkMzeVqzwjMyc1OiM1p0BDM9YKJKRXnJOaWqBhqPn/PwA "Python 3 ‚Äì Try It Online")
Improved by [Sisyphus](https://codegolf.stackexchange.com/users/48931/sisyphus)
[Answer]
# [Desmos](https://desmos.com/calculator), 5+3+3+2=13 bytes
Ticker expression (5 bytes)
```
a->-a
```
Ticker repeat delay (3 bytes)
```
999
```
Main expressions (3 bytes)
```
a=1
```
2 bytes for "file boundaries" (treat each expression as a separate "file"; there are 3 "files", so there are two "file boundaries", as per this [comment](https://codegolf.meta.stackexchange.com/questions/19316/scoring-desmos-equations#comment74833_19317))
[Try It On Desmos!](https://www.desmos.com/calculator/b0oevnbpmy)
To run, click the ticker icon (the metronome) near the top left of the screen. This switches the variable `a` between the values `1` and `-1` every 999 milliseconds. While this isn't outputting onto the console or stdin in the traditional sense, you can still clearly see the code switching between the `1` and the `-1`, which hopefully emulates outputting close enough.
[Answer]
# [C (gcc)](https://gcc.gnu.org/), 30 bytes
Prints a newline every second.
```
main(){main(sleep(puts("")));}
```
[Try it online!](https://tio.run/##S9ZNT07@/z83MTNPQ7MaTBXnpKYWaBSUlhRrKClpampa1/7/DwA "C (gcc) ‚Äì Try It Online")
[Answer]
# [Factor](https://factorcode.org/), 18 bytes
```
[ .s ] 1e9 every .
```
[Try it online!](https://tio.run/##S0tMLskv@h8a7OnnbqVQkpmbWlSsUFCUWlJSWVCUmVeiYP0/WkGvWCFWwTDVUiG1LLWoUkHv/38A "Factor ‚Äì Try It Online")
`every` calls a function each time a duration has passed. If `every` is not given a duration such as `1 seconds`, and instead given a number, it defaults to nanoseconds. Thus, one billion (or 1e9) means one second. `.s` simply prints the contents of the data stack without consuming them, which in this case will print the timer object `every` uses to do its thing. The `.` at the end is necessary to satisfy the stack effect checker by removing the item on the data stack (because Factor programs must end with an empty stack), even though it will never be reached.
[Answer]
# Javascript, ~~22~~ ~~20~~ 19 Bytes
Thanks to @Kaiido for -2 Bytes
Thanks to @Elias Holzmann for -1 Bytes
```
setInterval({},1e3)
```
<https://jsfiddle.net/ry2sgkz7/>
[Answer]
# shell + GNU/Linux core utils, 11 bytes
`watch -n1 w`
A bit of a boring answer.
[Answer]
# [\*><>](https://github.com/redstarcoder/go-starfish), 4 bytes
Prints "10" on startup, and once every second
```
a:nS
```
[Try it online!](https://tio.run/##Ky5JLErLLM74/z/RKi/4/38A "*><> ‚Äì Try It Online")
## Explanation
```
a      # Push 10 onto the stack
 :     # Duplicate it
  n    # Pop a value off the stack, and print it as a decimal number
   S   # Pop a value off the stack, and sleep for 100ms * the popped value
```
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal) `j`, 5 bytes
```
‚ÅΩkN·∏ûU
```
Don't [Try it Online!](https://vyxal.pythonanywhere.com/?v=2#WyJqIiwiIiwi4oG9a07huJ5VIiwiIiwiIl0=) - it doesn't work there.
This one's kind of hilarious. It creates an infinite list of times, and then uniquifies them. The `j` flag is necessary due to how Vyxal handles printing infinite lists.
```
   ·∏û  # Generate an infinite list from...
‚ÅΩ     # A function that returns
 kN   # The current time of day (hh:mm:ss)
    U # Get unique values
```
[![enter image description here](https://i.stack.imgur.com/6zJUc.png)](https://i.stack.imgur.com/6zJUc.png)
[Answer]
# [MATL](https://github.com/lmendo/MATL), 7 bytes
```
`@D1Y.T
```
This displays the natural numbers in order. Try at [MATL online](https://matl.io/?code=%60%40D1Y.T&inputs=&version=22.7.4)!
### How it works
```
`      % Do...while
  @    %   Push iteration index, starting at 1
  D    %   Display
  1    %   Push 1
  Y.   %   Pause for that many seconds
  T    %   Push true. This is used as loop condition, causing an infinite loop
       % End (implicit)
```
[Answer]
# [(,)](https://esolangs.org/wiki/(,)), ~~60~~ ~~62~~ 61 Chars or \$61\log\_{256}(3)\approx\$ 12.09 Bytes
```
((),((()))((())))((()),((())))(,((()),(),(),,((())),()),,,())
```
```
((),((()))((()))) Sets variable 1 to -2.
((()),((()))) sets variable -2 (time) to itself. (AKA setting the current time to 0)
(, Start of loop
((()),(),(),,((())),()) If variable -2 (time) is at least 1, reduce it by 1 and output 1\n
,,,()) Loop forever
```
First solution sometimes had the second output less than a second after the first.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 5 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
1≈ìS·πÑ¬ø
```
A full program which prints `1` and a newline and then after (just over) one second has elapsed prints another, then repeats this step forever.
It's "just over" as it takes some time to do the work. The first pause could take more than 1 second on slow hardware as Jelly has to initialise Python, and itself (create an interpreter, import some cruft, etc.) and parse the code. Subsequent pauses are unlikely to be over the 1.01 second threshold however as it just needs to check that the result is truthy and print to STDOUT.
**[Try it online!](https://tio.run/##y0rNyan8/9/w4c6Wo5ODD@3//x8A "Jelly ‚Äì Try It Online")** (TIO does not output anything as a program runs, but kill it while in flight and take a look; killing within a second should give a single `1` in the "Output" section, leaving it running longer should give more outputted `1`s for each second that passed.)
### How?
```
1≈ìS·πÑ¬ø - Main Link: no arguments
1     - set the left argument to one
    ¬ø - while...
 ·πÑ    - ...condition: print {left=1} and a newline, and yield {left=1}
  ≈ìS  - ...action: sleep for {implicit right=left=1} seconds and yield {left=1}
```
---
Replace `·πÑ` with `»Æ` for no newlines.
[Answer]
# [PHP](https://php.net/), ~~22~~ ~~21~~ 17 bytes
```
for(;;a)sleep(1);
```
[Try it online!](https://tio.run/##K8go@G9jXwAk0/KLNKytEzWLc1JTCzQMNa3//wcA "PHP ‚Äì Try It Online")
I think the naive approach will be the shortest here. On TIO the output will be visible only when stopping the program of course
EDIT: saved 1 byte by echoing the falsey result of `sleep`, it works because `sleep` returns zero instead of `false` which would have lead to an empty string
EDIT 2: stole the suggestion from [this JS answer](https://codegolf.stackexchange.com/a/262209/90841) by triggering a warning instead of an echo
[Answer]
# TI-Basic (TI-84+), 22 bytes
```
startTmr
While 1
If checkTmr(Ans:Then
Disp Ans
startTmr
End
End
```
[Answer]
# [Racket](https://racket-lang.org), ~~43~~ ~~37~~ ~~28~~ 26 bytes
## Changelog
1. Thanks to [@Dadsdy](https://codegolf.stackexchange.com/users/118038/dadsdy) for the `-2` bytes.
2. The `-4` bytes comes from converting `#lang racket` to `#!racket`.
3. Another `-9` as I found out that language statements may go into the header of TIO, and as such, don't contribute to number of bytes.
4. I just learnt about Racket's `do` loop! `-2` bytes! üéâ
## Code
```
(do()(#f)(write(sleep 1)))
```
[Try it online!](https://tio.run/##K0pMzk4t@a@ck5iXrlAE4Wik5GtoaiinaWqUF2WWpGoU56SmFigYampq/v8PAA "Racket ‚Äì Try It Online")
---
## Explanation
We create a [*do*](https://docs.racket-lang.org/reference/for.html#%28form._%28%28lib._racket%2Fprivate%2Fmore-scheme..rkt%29._do%29%29) loop that runs infinitely. Since we used `#f` (false) in `do`s second argument, the loop won't terminate as it will only terminate if there is a `#t` value.
If we were to expand this out and make it more readable, it would look like this:
```
(do () (#f)
  ; (sleep 1) doesn't return anything, so #<void> will be printed.
  (write (sleep 1)))
```
The `do` loop acts a bit similar to JavaScript's `while` loop:
```
while (!false) {
  // ...
}
```
[Answer]
# [GFA-Basic](https://en.wikipedia.org/wiki/GFA_BASIC) 3.51 (Atari ST), 15 bytes
A manually edited listing in .LST format. All lines end with `CR`, including the last one.
```
DO
?0
PA 50
LO
```
which expands to:
```
DO
  PRINT 0
  PAUSE 50
LOOP
```
We could use `DELAY 1` instead of `PAUSE 50`. Unfortunately, the shortest unambiguous abbreviation of `DELAY` is `DELA`.
### Output
After 5 seconds:
[![output](https://i.stack.imgur.com/GbvB4.png)](https://i.stack.imgur.com/GbvB4.png)
[Answer]
# x86-16 machine code, PC DOS, 14 bytes
```
00000000: b42c cd21 3ac6 74fa 8ac6 cd29 ebf4       .,.!:.t....)..
```
**Listing**
```
B4 2C       MOV  AH, 2CH        ; DOS API get system time function 
        SEC_LOOP: 
CD 21       INT  21H            ; Read time: DH = seconds 
3A C6       CMP  AL, DH         ; second changed? 
74 FA       JE   SEC_LOOP       ; continue polling if not 
8A C6       MOV  AL, DH         ; save new second 
CD 29       INT  29H            ; write AL to console 
EB F4       JMP  SEC_LOOP       ; loop indefinitely 
```
A standalone executable DOS COM program. Spams the DOS time function and writes the corresponding ASCII codepoint for the number of seconds.
*Several minutes later...*
[![enter image description here](https://i.stack.imgur.com/TtcIH.png)](https://i.stack.imgur.com/TtcIH.png)
[Answer]
## Batch, ~~15~~ ~~13~~ 9 bytes
```
ping -t 0
```
After some initial output, outputs the following every second:
```
PING: transmit failed. General failure.
```
Edit: Saved 4 bytes thanks to @c--.
Previous 15-byte solution:
```
timeout/t 1
%0
```
Repeatedly outputs the following:
```
C:\Users\Neil>timeout/t 1 
Waiting for 1 seconds, press a key to continue ...0
C:\Users\Neil>262205.bat
```
When output is to the screen, the cursor is moved so that the `0` overwrites the `1`.
[Answer]
# [C# (Visual C# Interactive Compiler)](http://www.mono-project.com/docs/about-mono/releases/5.0.0/#csc), 45 bytes
Nothing special
```
for(;;){Thread.Sleep(1000);Console.Write(1);}
```
[Try it online!](https://tio.run/##Sy7WTS7O/F9anJmXrhBcWVySmqsXklGUmpgCFLD@n5ZfpGFtrVkNEdILzklNLdAwNDAw0LR2zs8rzs9J1QsvyixJ1TDUtK79/x8A "C# (Visual C# Interactive Compiler) ‚Äì Try It Online")
[Answer]
# [Nim](https://nim-lang.org/), 36 bytes
```
import os
while 0<1:echo 1;sleep 999
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m704LzN3wYKlpSVpuhY3VTJzC_KLShTyi7nKMzJzUhUMbAytUpMz8hUMrYtzUlMLFCwtLSFqoVpgWgE)
[Answer]
# [Perl 5](https://www.perl.org/), 19 bytes
```
say 2 while sleep 1
```
[Try it online!](https://tio.run/##K0gtyjH9r1Jja2itoFxckl@gEOLpr1uSmZuaX1qikFaUn6tQUJRalppXkpmXrgAUKygt@V@cWKlgpFCekZmTqlCck5paoGD4//@//IKSzPy84v@6vmWmeoYGAA "Perl 5 ‚Äì Try It Online")
[Answer]
# [Julia 1.0](http://julialang.org/), ~~24~~ 21 bytes
```
!x=!show(sleep(1))
!0
```
[Try it online!](https://tio.run/##yyrNyUw0rPj/X7HCVrE4I79cozgnNbVAw1BTk0vR4P9/AA "Julia 1.0 ‚Äì Try It Online")
-3 bytes thanks to ovs: improve recursion, and redefine an operator (An argument has to be passed to it, but this can be ignored by the function)
[Answer]
# [Japt](https://github.com/ETHproductions/japt), ~~7~~ 4 [bytes](https://en.wikipedia.org/wiki/ISO/IEC_8859-1)
Outputs a `ReferenceError`.  
Any lowercase letter word work instead of the second `i`.
```
A¬≥ii
```
[Test it](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&header=JGNvbnNvbGUuY2xlYXIoKSQ&code=QbNpaQ) (Open your browser's console)
[Answer]
# [ELF (x86/x64, Linux)](https://refspecs.linuxfoundation.org/elf/elf.pdf), 112 bytes
Prints 'A' about once per second, indefinitely.
```
00000000: 7f45 4c46 fec0 505f e81b 0000 0000 0000  .ELF..P_........
00000010: 0200 3e00 0000 0000 0400 0000 4100 0000  ..>.........A...
00000020: 3800 0000 0000 0000 5e40 80c6 3f50 5a0f  8.......^@..?PZ.
00000030: 0504 2256 eb32 3800 0100 0000 0500 0000  .."V.28.........
00000040: 0000 0000 0000 0000 0000 0000 4100 0000  ............A...
00000050: 0100 0000 0000 0000 7000 0000 0000 0000  ........p.......
00000060: 7000 0000 0000 0000 5faf 0f05 eb96 0000  p......._.......
```
[Try it online!](https://tio.run/##bZG7DsIwDEV3vsLiAyzn4TQw8BhgYujEwAAqVTwx8P9LSUTSUNoMViL7ntwrh5cMA@WzhUYsg@2tAwk9ARMLBK@ekNo/BfB0OSO2D8xn9SWoyCAdB0yYzJMtN6sqA3dFjsfK0JFh/FSeCgdL4Kl3YITjsyMB8Fl/PyDu21thmOSDyYLW7CA8jc7I8ffYrT7WV9Qe/7LYxKC5j1omWXApCyeGmiubBdrIeE99uLSXhXmWToCEOObbuMwo2rKYYfgA "ELF (x86/x64, Linux) ‚Äì Try It Online") (Prints 60 `A`'s before TIO kills the process)
## Explanation
The file abuses a lot of undefined behavior within the Linux ELF loader; the kernel is able to make a lot of (correct) assumptions when certain fields are not the right value. [Here](https://tio.run/##jVRNc5swEL3zK3bSziSZxI0/sOshpx7aU/9BppMRaGXUAYQlYeP8eXdXQGyTZBoOQuxKb6X33iKcwzItDpNKuPJ4fEq1d7CK/0TRk7EbmNLkEZQuENJGF1JXG8BCgbKmBJdZ4bOcV/BusGJPuW88nZjuAyYq1VUU0fQ5lzaJgB6ZwrT9ru5pjJdhzMK4gseQgKufv39dMexsDunBo4McLYI3kIsdgjMlgmqqCCtvDwkEUF1lIApC6LeEYN24nI7VUngWwl3U1GClvgxmoiigwtZTeNlDhITXJR1gEU5NuaZqHMouJfd03jkFscWs8SIt8BRfICVEKaFdryar@AwrHmGFLVsosXxOhcO7cC1GDe/a6MoPa2prNkwkZXlqRUnUCIkWjFIOfSAtPidNGQulsR1hfL/kxIEbcSCkBKcLFmOhKBV/kspR0B1cYPNSCwYXhL2I3xVpfJa/ZQ0uN9ZDIZw/23LG8PotDU6/YDSwlLzNk4cKIyRzq5kUdjbxa5h9uLHtLQj/qsSp1IyQvhDHIzgHDwGOlQeHmxJ7qTqh55dCf7SYiJm2y9OyG6wk1@L@oVvc0j5L5e7YZYMR@oaiTZ3wdIlwmbGZLhbstA2XM2SrB2poFVbbra8T3jM7PylHBzAGZmIpH159rf@v6mqxKde9J9mOSlfUqeTHQFPE@iYfNyZ5ycnPGOzkmKGBXi1DvbRDKpebZpPTC4mYYCu/N/3BiG@Kj@0iyCMvaM09Jw/8SVjO6/CvQNk377tqc9WgAJOfZkw3yajYNGQ3rkW/vBlc/7iOBrESwG0TwtP@iaKB1S73FSaD9MfjPw) is the full NASM source.
Basically, the executable is just an ELF header, a program header (partially merged into the ELF header), and the actual program (which is spread throughout the two headers so that it doesn't take up any additional space). The full program calls `sys_write(stdout, "A", 1)`, then `sys_nanosleep({tv_sec=1, tv_nsec=112}, <nonsense valid pointer>)`, and then loops back to the start.
[Answer]
# [R](https://www.r-project.org/), ~~27~~ 25 bytes
*Edit: -2 bytes thanks to [@Dominic van Essen](https://codegolf.stackexchange.com/users/95126/dominic-van-essen).*
```
repeat show(Sys.sleep(1))
```
[Try it online!](https://tio.run/##K/r/vyi1IDWxRKE4I79cI7iyWK84JzW1QMNQU/P/fwA "R ‚Äì Try It Online")
This works well on my local machine, but TIO accumulates output until it finishes execution, so you don't see the progress.
[Answer]
# [Arturo](https://arturo-lang.io), 23 bytes
```
while√∏[1:s>>{a}1pause]
```
```
while√∏[     ; start infinite loop (while loop with null for condition)
    1:s     ; push duration of 1 second to stack
    >>{a}1  ; create/overwrite file named a
    pause   ; pause execution for one second (which we left on the stack earlier)
]           ; end while
```
[Answer]
# [Pyth](https://github.com/isaacg1/pyth), 6 bytes
```
#.d
.j
```
[Try it online!](https://tio.run/##K6gsyfj/X1kvhUsv6/9/AA "Pyth ‚Äì Try It Online")
### Explanation
```
#        # loop forever until error (no error will occur)
   .j    # imaginary number i, printed
 .d      # sleep for abs(i) seconds
```
It may seem weird that I have to sleep for \$|i|\$ seconds, why not just 1? While that would save a byte, unfortunately `.d1` is a predefined macro which returns the amount of time which has passed since the program started, which is not really useful for this challenge.
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 10 bytes
```
Ôº≤Ôº∑œÜœàÔº∞Ôº©¬¨Œ£Ôº´Ôº´
```
[Try it online!](https://tio.run/##S85ILErOT8z5/z8oNa0otTgjPCMzJ1UjTUehUlPBtzSnJLOgKDOvRMM5sbhEwy@/RCO4NFcjIDU1W0MTBKz///@vW5YDAA "Charcoal ‚Äì Try It Online") Link is to verbose version of code. Uses control codes to toggle the top left corner between `1` and `0`, so on TIO you need to let it run for a few seconds and then interrupt it to see the control codes and `1`s and `0`s. Explanation:
```
Ôº≤Ôº∑œÜœà
```
Repeat indefinitely, showing the current canvas with a 1000ms delay on each repeat.
```
Ôº∞Ôº©¬¨Œ£Ôº´Ôº´
```
Toggle the current character between `1` and `0`.
[Answer]
# [Lua](https://www.lua.org/), 50 bytes
```
o=os.time::a::t=o()repeat until t<o()print()goto a
```
[Try it online!](https://tio.run/##yylN/P8/3za/WK8kMzfVyirRyqrENl9Dsyi1IDWxRKE0ryQzR6HEBihSUJSZV6KhmZ5fkq8A1AMA "Lua ‚Äì Try It Online")
A platform independent solution. You *can* make this shorter by using `os.execute`, but that solution is both platform dependent and not very interesting.
]