g | x | w | all

Bytes	Lang	Time	Link
003	How dare you fuck the brain	241004T150703Z	Gleb
001	True	241114T103017Z	Gleb
005	Setanta	250828T195236Z	bb94
004	'Python' is not recognized	241104T202558Z	Gleb
022	Bespoke	250823T081212Z	Josiah W
008	PARI/GP	250818T180927Z	Charles
002	TECO	250719T000404Z	Mark
001	Just	241027T210109Z	Gleb
017	SAKO	250314T153409Z	Acrimori
009	TeX	250306T165348Z	jlab
003	FRACTRAN	250227T011310Z	Lucenapo
003	Regenerate	241207T025302Z	Unrelate
004	CASIO BASIC CASIO fx9750GIII	241120T161150Z	madeforl
001	BrainChild ASM	241112T001652Z	ATaco
003	!aBF'	241029T171505Z	Gleb
002	iogii prealpha	241027T213835Z	Unrelate
045	x86 ELF executable	151003T033143Z	casey
008	Qdeql	240909T002123Z	Bbrk24
013	tinylisp	240824T211306Z	Andrew B
015	AWK	240520T212515Z	C K
006	Befalse quirkster	240520T054622Z	Bubbler
002	YASEPL	240222T151313Z	madeforl
005	ELVM IR	240222T094038Z	None1
053	Java JDK	151002T172853Z	Geobits
003	brainfuck	151002T172754Z	user4264
003	///	151004T002954Z	Dennis
003	Arm/Thumb/MIPS/SPARC/PowerPC assembly	230624T132139Z	landfill
001	Thunno 2	230704T183824Z	The Thon
005	Tsept v1.0	230622T191656Z	kevidryo
000	Desmoslang Assembly	230607T033724Z	Dadsdy
nan		230607T033539Z	Dadsdy
003	Grass	230606T224053Z	bluswimm
002	[min]mod	230417T053701Z	Peter
012	Swift	230322T214919Z	user1171
001	Thunno	230322T072726Z	The Thon
009	Arturo	230322T053322Z	chunes
002	TacO	230322T051229Z	ATaco
003	Rattle	220928T013440Z	d01
nan	Fig	220831T172759Z	Seggan
003	Knight	220805T024409Z	97.100.9
006	DC	151230T204107Z	user1921
002	makina	220520T123646Z	Ginger
003	BitCycle	220514T175058Z	BowlingP
006	Rust	220512T175953Z	Sapherey
001	Exceptionally	220512T154826Z	DLosc
001	rSNBATWPL	220512T143501Z	lyxal
001	Lost	220222T185741Z	autumn
007	Plumber	191211T162355Z	rydwolf
000	Uselesslang	211225T155403Z	Fmbalbue
012	KonamiCode	211112T152721Z	Ginger
002	Pure CPython 3.10 Bytecode	211030T084007Z	pxeger
000	ErrLess	211023T074431Z	Ruan
006	Binary Pi Calculus	211029T224329Z	Soup Gir
002	RISCV machine code	211029T190322Z	Dark Kir
047	Aussie++	211029T175335Z	Bbrk24
004	Braingolf	170606T063416Z	Mayube
001	Vyxal	210913T171834Z	das code
020	Taxi	170721T211420Z	Engineer
007	Maze	210911T220412Z	cnamejj
625	Java6 25 Bytes	151003T090503Z	Akash Th
004	Minim	210814T005323Z	Christia
027	Arduino	210813T043600Z	Bbrk24
001	StackLang	210628T182755Z	Dominice
001	Daoyu	210628T173253Z	Jay Ryan
008	Mascarpone	210628T164326Z	Soup Gir
020	h	210628T162036Z	AndrewTh
002	yuno	210622T043314Z	hyperneu
003	Knight	210622T042220Z	EasyasPi
004	Locksmith	210621T162045Z	Jay Ryan
000	Dis	210621T133404Z	user1004
018	Elixir	210528T194309Z	Makonede
002	x86 machine code	210529T213512Z	Febriyan
010	MMIXAL	210513T190042Z	NoLonger
005	Splinter	210512T094156Z	emanresu
005	Jellyfish	210512T092221Z	Razetime
017	Cgcc	210426T073606Z	dnn25519
026	CSASM v2.4.0.2	210426T072346Z	absolute
002	ABC	210424T074820Z	wasif
002	Duocentehexaquinquagesimal	210414T201739Z	Makonede
023	Scratch	210412T233935Z	Nolan
002	convey	210404T114741Z	emanresu
002	BRASCA	210122T093437Z	SjoerdPe
404	Pxem	210317T035112Z	user1004
005	Prolog	151002T203148Z	coredump
014	Python 3	210312T054013Z	M Virts
058	vJASS Warcraft 3	200419T230410Z	ネルマン
001	Canvas	180302T175535Z	hakr14
039	Racket	210219T190214Z	MLavrent
010	Factor	210218T235026Z	Bubbler
002	ARM Thumb2 machine code	210218T230537Z	EasyasPi
000	C GNUEFI	210218T164220Z	AliFurka
001	Vyxal	200929T071148Z	lyxal
006	Perl 5	201220T043423Z	Xcali
008	C#9	201123T200145Z	Kirbykir
008	Pixilang	201105T024824Z	Danis
003	Arn	201105T022455Z	ZippyMag
015	Forth gforth	201103T042110Z	Razetime
011	NDBall	201102T142517Z	QTpye
010	Poetic	201002T023614Z	JosiahRy
015	AWK	170411T141942Z	Robert B
003	sed	200924T072153Z	Chris
008	Marbelous	200924T073345Z	jonatjan
004	International Phonetic Esoteric Language	191006T023141Z	bigyihsu
001	05AB1E	200924T002001Z	Makonede
002	ezfuck	170420T192521Z	Carcigen
005	Add++	200923T112444Z	caird co
009	Rockstar	200923T111420Z	Shaggy
008	Haskell	200923T100013Z	Monad
010	Flurry nnn	200811T094718Z	Bubbler
015	Python 3	200811T140513Z	Eesa
002	MAWP v1.1	200807T043606Z	Razetime
006	Integral	200806T055249Z	lyxal
041	Brainetry	200611T150005Z	RGS
018	Rust	200611T224925Z	Golden_b
006	Ruby	200609T204617Z	Sapphire
005	J	200420T064053Z	Bubbler
009	Haskell	200420T031537Z	MLavrent
004	TIBASIC	200418T193504Z	raddish0
013	I like frog	200418T152928Z	user9275
006	J	200418T124442Z	PkmnQ
002	Husk	200418T115416Z	user9206
014	Kotlin	200321T082433Z	snail_
001	W i	191221T122145Z	user8505
004	Taktentus	191231T153529Z	0x3
003	tq	191231T152338Z	user8505
005	Intcode	191224T035611Z	The Fift
000	><>	190907T164300Z	Sagittar
002	QWOP	190909T172742Z	Sagittar
003	///	190907T201916Z	Sagittar
002	NULL	191211T174719Z	anatolyg
004	Whenever	191007T122637Z	AlienAtS
004	Nandy	190907T144504Z	user8505
005	1+	190907T011944Z	user8505
012	PHP	190925T063723Z	Night2
001	Cascade	190925T053314Z	Unrelate
017	Rust	190912T205511Z	Sagittar
003	Element	190911T150303Z	user8505
005	Kipple cipple	190909T190411Z	Edgex42
041	Pyramid Scheme	190910T163730Z	Khuldrae
002	Pizza Delivery	190907T034818Z	user8505
002	@	190907T031832Z	user8505
000	Fastlane	190907T031129Z	user8505
002	A0A0	190907T030044Z	user8505
000	And	190907T025631Z	user8505
001	ABC Esoteric	190907T012330Z	user8505
001	Stax	190822T013546Z	user8965
002	x8616 Assembly	190821T184219Z	640KB
002	Oasis	190815T145543Z	user8505
9312	jq n	190812T114458Z	user344
032	GOLANG 32 Bytes	190807T095855Z	dilwaria
1787	Malbolge	190811T100506Z	Kamila S
037	Forget	190806T202650Z	Benjamin
019	Forth	190809T140812Z	nonForgi
004	33	190807T082519Z	TheOnlyM
001	Backshift	190614T160407Z	user8505
013	Turing Machine But Way Worse	190513T052128Z	u-ndefin
007	VTL2	190531T144322Z	brhfl
000	Aheui	190531T101822Z	LegenDUS
007	Brian & Chuck	190531T101632Z	Dorian
001	Keg	190531T090234Z	lyxal
004	Stack Cats m	190531T065408Z	Unrelate
005	TIS100	190403T004516Z	Tux1
006	Crystal	190402T205902Z	RespiteS
001	Flobnar	180809T194906Z	Esolangi
016	INTERCAL	190402T091003Z	Unrelate
006	Commodore BASIC V2 Commodore 64/VIC20	180122T124210Z	Shaun Be
007	ink	190325T200418Z	Sara J
019	Idris	190325T161056Z	univalen
010	Tamsin	190323T052018Z	Esolangi
061	Shakespeare Programming Language	180915T022635Z	JosiahRy
000	Piet	180914T152432Z	kepe
046	Chef	151004T010904Z	ETHprodu
009	Lua	180806T003754Z	GalladeG
001	µ6	180806T032120Z	ბიმო
000	Lost	180806T051346Z	Jo King
006	Pepe	180805T200933Z	RedClove
009	JavaScript Node.js	180414T181456Z	Muhammad
001	Z80Golf	180624T204733Z	lynn
009	LOLZ	180624T200102Z	Cevat Ba
004	TIBASIC	151002T190654Z	Conor O&
002	TIBASIC	151002T223920Z	Stretch
015	HadesLang	180604T092255Z	Azeros
001	Z80 Machine Code	180604T073637Z	mazzy
003	beeswax	180603T012204Z	M L
001	Ahead	180603T031225Z	snail_
022	Q'Nial7	180603T020815Z	M L
006	DUP	180603T014940Z	M L
016	C gcc	180603T011231Z	Marhtini
000	Tcl/Tk	151005T040230Z	slebetma
000	Gol><>	180415T060513Z	Bubbler
008	Javascript	180301T161037Z	Stefan O
010	C tcc	180414T175632Z	Dennis
004	MachineCode	180307T014721Z	MD XF
007	VBA 7 Bytes	180306T232323Z	Absinthe
008	Beatnik	151003T184447Z	MickyT
013	mIRC v.7.49	180302T112308Z	Manish K
001	Japt	180306T152724Z	Shaggy
021	Forth	151002T212554Z	mbomb007
005	Reflections	180305T210859Z	wastl
132	ORK	180303T044844Z	DLosc
005	Dreaderef	180303T043133Z	Esolangi
037	Python 3	180302T154730Z	Mercury
003	Sceql	180302T091615Z	Weijun Z
nan	So I suppose I can create a new language and develop its intepreter for this answer	180302T080854Z	Shieru A
008	PainFlak	180301T191216Z	user6318
010	Retina	151002T175822Z	TheNumbe
915	Clojure	180213T020204Z	NTCG
000	Wumpus	180212T052227Z	Jo King
008	PHP 7	180212T202557Z	Artistic
044	Visual Basic .NET .NET Core	180212T204421Z	Taylor R
012	MYBASIC	180212T203950Z	Taylor R
007	Yabasic	180212T203527Z	Taylor R
007	VBA	180212T203209Z	Taylor R
007	uBASIC	180212T202946Z	Taylor R
001	axo	180212T201925Z	qqq
001	Stax	180212T160425Z	Weijun Z
005	FALSE	180212T154403Z	12Me21
001	Chip8	171012T140323Z	12Me21
011	Swift	180212T093743Z	Dan Karb
004	Momema	180212T070552Z	Esolangi
000	Forked	180212T051059Z	MD XF
001	Aceto	171130T072547Z	qqq
021	Acc!!	180112T003849Z	qqq
002	Piet	180122T115729Z	user7277
010	SNOBOL4 CSNOBOL4	180118T233643Z	Giuseppe
003	Retina	151002T191011Z	Martin E
003	Pyt	180112T011047Z	mudkip20
001	Aceto	170606T090445Z	L3viatha
016	Whispers	171210T150653Z	caird co
002	Husk	171121T200248Z	ბიმო
010	REXX	171116T093105Z	idrougge
001	Implicit	170910T031153Z	MD XF
002	Z80	171120T074629Z	Heimdall
050	Java OpenJDK 8	171116T095617Z	Luca H
009	Batch	160220T143058Z	ghosts_i
009	JavaScript	171110T202927Z	xDest
004	Operation Flashpoint scripting language	171110T191910Z	Steadybo
008	BrainFlak	171103T150318Z	qqq
005	Ruby w/Juby	170210T213901Z	Cyoce
023	Java	171024T114924Z	Olivier
001	Vitsy	151020T154025Z	Addison
008	Smalltalk80	171012T211311Z	aka.nice
022	Hodor	171012T191020Z	KSmarts
012	4	171012T181927Z	KSmarts
013	jq 1.5	170930T193341Z	jq170727
011	Nhohnhehr	170930T181839Z	Erik the
078	Thotpatrol	170904T220045Z	Mr. Negi
000	Motorola MC14500B Machine Code	151104T174835Z	Zach Gat
001	Cubically	170804T190747Z	MD XF
028	Emojicode	170730T002210Z	betseg
003	Newline	170720T164647Z	user6318
003	Lean Mean Bean Machine	170718T105649Z	Mayube
025	Unreadable	170606T085315Z	Mayube
173	XSLT	170710T040801Z	Silvio M
026	MOO	170709T230023Z	The Fift
003	Triangular	170611T002100Z	MD XF
018	INTERCAL	151002T192732Z	kirbyfan
001	Fission 2	170606T080826Z	Mayube
006	Decimal	170606T035400Z	MD XF
000	Alice	170411T132827Z	Martin E
014	Lua and RBX.Lua	170401T181915Z	Josh
003	Samau	151223T091751Z	alephalp
002	QBIC	151224T191422Z	steenber
001	OIL	170331T105027Z	Erik the
004	Forte	170307T224001Z	Pavel
003	BitCycle	170211T061410Z	DLosc
005	SmileBASIC	170124T203241Z	12Me21
005	Chip	170130T170847Z	Phlarx
001	PKod	170127T230702Z	Offtkp
009	Pari/GP	170124T204336Z	Gottfrie
007	tcl	170105T224924Z	sergiol
006	DUP	161223T233226Z	M L
003	GNU Sed	170105T125211Z	zeppelin
002	APL	170105T125741Z	Adá
001	7	170105T095021Z	user6213
007	Excel VBA	170105T031302Z	Taylor R
007	uBASIC	161229T222621Z	Pavel
012	Scala	161229T215031Z	firephil
013	tinylisp	161226T190524Z	DLosc
027	Lithp	161225T060557Z	Andrakis
006	FALSE	161223T225022Z	Conor O&
nan	Pushy	161220T100502Z	user4180
005	Casio FX7000G	161210T213458Z	FlipTack
000	Cubix	160907T093250Z	ETHprodu
003	TI83 Hex Assembly	161201T195909Z	habs
002	Microscript	151002T201341Z	SuperJed
010	Clojure	161201T005424Z	Carcigen
003	Commodore Basic	151002T222653Z	Mark
009	PHP	161201T003137Z	Titus
040	Lithp	161116T215353Z	Andrakis
695	Unary	161016T081746Z	Linnea G
003	D2	161021T170912Z	TuxCraft
002	Bash	161018T190837Z	Joshua D
002	05AB1E	161016T170417Z	Oliver N
026	Emotinomicon	160925T134430Z	Erik the
000	Visity	161016T073548Z	Linnea G
002	CMD	161016T072635Z	Linnea G
004	dotsplit	161016T063821Z	Destruct
006	Sinclair ZX81 Basic	161006T135443Z	Vatine
018	Racket	161006T111410Z	rnso
020	Lolo	161006T103829Z	user4701
002	ABCR	161006T091227Z	Steven H
002	LI	161004T081810Z	Steven H
006	Bash or perl	160928T003010Z	BenGoldb
nan		160927T215548Z	Cyoce
026	PHP	160927T223802Z	Titus
010	Copy	160925T134558Z	TuxCraft
003	Turtlèd	160918T084725Z	Destruct
009	S.I.L.O.S	160922T004841Z	acrolith
003	Binary Lambda Calculus	160531T223236Z	Zwei
003	Element	151002T180930Z	PhiNotPi
004	Ru	160902T152448Z	TuxCraft
024	Logicode	160902T073007Z	clismiqu
050	Java	160901T142735Z	Shaun Wi
011	S.I.L.O.S	160901T142455Z	betseg
008	TSQL	160901T141247Z	S.Karras
016	Nim	160831T213846Z	Copper
027	Gaot++	160723T173014Z	LegionMa
002	Sesos	160717T023945Z	Dennis
002	AlphaBeta	160712T184831Z	LegionMa
000	Benul	160712T152819Z	LegionMa
004	MarioLANG4 Bytes	160701T103235Z	user5420
005	Trigger	160619T154326Z	LegionMa
002	Enigma2D	160613T121221Z	LegionMa
002	Brachylog	160610T075351Z	Fatalize
007	0815	160608T120209Z	Erik the
005	Linux shebang	160608T090127Z	username
008	BASIC	160608T090858Z	username
002	niblet	160529T121153Z	LegionMa
001	BSM	160217T022424Z	LegionMa
006	Subskin	160220T024748Z	LegionMa
000	Barely	160527T143336Z	LegionMa
020	Churro	160527T131105Z	LegionMa
004	Noobinary	160526T192032Z	LegionMa
003	Glypho	160521T143729Z	LegionMa
029	Ceylon	151005T184306Z	Paŭlo Eb
003	Subleq bytecode	160324T153637Z	username
005	Tellurium	160515T155839Z	m654
001	Pyke	160515T131247Z	Blue
003	Seed	160514T074116Z	user5340
002	Dumbfuck	160513T115238Z	LegionMa
006	Grocery List	160513T112210Z	LegionMa
001	ACIDIC	160509T112741Z	LegionMa
nan		160505T181545Z	univalen
001	GPRX 3000	160501T191314Z	LegionMa
005	XRF	160429T104905Z	LegionMa
005	Revaver2pi	160429T103315Z	LegionMa
002	MATL	160419T113113Z	Stewie G
010	PRINDEAL	160423T135117Z	The Fift
002	evil	160423T131802Z	LegionMa
006	Braille	160420T111644Z	LegionMa
005	tinyBF	160420T102809Z	LegionMa
004	Codan	160420T102214Z	LegionMa
071	Pancake Stack	160307T211751Z	LegionMa
001	V	160419T064002Z	DJMcMayh
000	Gammaplex	151003T011522Z	jimmy230
000	Parallax Assembly	160417T002338Z	Joshua
008	JavaScript	151004T204739Z	Cyoce
002	Fuzzy Octo Guacamole	160411T161026Z	Riker
002	C64 Machine Code	151002T184722Z	James Ki
017	Sh	160411T160218Z	Erik the
002	Jumper	160407T233352Z	LegionMa
122	The Infamous Shakespeare Programming Language	160401T123245Z	clamchow
002	Pylongolf2	160401T074045Z	user4701
006	Cy	160325T064244Z	Cyoce
010	Bash	160329T014950Z	hyperneu
004	MNNBFSL	160327T213709Z	LegionMa
001	Jelly	160327T061408Z	Dennis
011	Come Here	160324T223649Z	SuperJed
004	WhoScript	160325T014852Z	MCS-Kaij
079	Python 3	151019T221029Z	cat
004	Mathcad	160324T133946Z	Stuart B
009	ForceLang	160229T203443Z	SuperJed
015	Factor	160320T003655Z	cat
006	Perl	160316T161955Z	Grimmy
001	Gogh	160316T031310Z	Zach Gat
008	Mathematica	151003T001606Z	LegionMa
004	Hoon	160307T225625Z	RenderSe
007	Grond	160308T162017Z	Bald Ban
003	Milky Way 1.6.5	160308T001259Z	Zach Gat
002	DUP	160301T041323Z	Mama Fun
004	Pylons	160229T203910Z	Morgan T
016	GNU Make	160221T151605Z	ugoren
1186	C	160221T145716Z	ugoren
002	NTFJ	160220T172500Z	Conor O&
007	Carriage	160220T121235Z	LegionMa
004	Puzzlang	160220T023205Z	LegionMa
007	Magic	160217T114223Z	LegionMa
002	Condit	160216T173911Z	LegionMa
133	RPG fixed	160216T144334Z	Andreas
030	Oracle PL/SQL 11.2	160216T150352Z	Jeto
020	Sally	160216T134818Z	LegionMa
007	2ill	160215T155834Z	LegionMa
006	Postscript	160213T000501Z	Zakipu
014	Lua	160130T221251Z	QuertyKe
036	C#	151002T173610Z	Namaskar
009	Perl 5	160125T195437Z	cat
007	Perl 6	160125T195146Z	cat
002	Mouse16	160118T202745Z	cat
056	Mmmm	160113T021221Z	LegionMa
009	GOTO	160111T225016Z	LegionMa
004	Dirst	160110T163034Z	LegionMa
014	KimL	160102T144000Z	LegionMa
008	Skull	160102T123803Z	LegionMa
002	Etre	160102T121010Z	LegionMa
002	STXTRM	160102T122357Z	LegionMa
005	ResPlicate	151231T071127Z	quintopi
001	Spiral	151231T065620Z	quintopi
001	Mumps	151230T210340Z	zmerch
024	𝔼𝕊𝕄𝕚𝕟	151106T045123Z	Mama Fun
007	Befalse	151228T165557Z	cat
003	BASIC QBasic 4.5	151002T211951Z	mbomb007
034	beeswax	151225T194134Z	M L
005	Quipu	151226T185008Z	Martin E
006	Aubergine	151225T195934Z	LegionMa
007	QBasic	151224T185913Z	steenber
001	ROOP	151224T030103Z	DarkPhan
003	Mouse	151002T183712Z	Alex A.
009	Emacs Lisp	151214T140201Z	Lord Yuu
032	Go	151121T000433Z	cat
002	Mouse2002	151214T134615Z	cat
008	AutoHotkey	151128T203143Z	errorsev
002	Seed	151111T135728Z	Bassdrop
008	Javascript	151128T151050Z	user4616
006	Arcyóu	151127T101020Z	jqkul
007	Marbelous	151118T060301Z	Sparr
008	BASIC	151114T232340Z	takra
011	Thue	151114T033209Z	SuperJed
008	ShapeScript	151114T033002Z	Dennis
202	Minecraft snap. Ver. 15w46a	151112T225012Z	Addison
002	BotEngine	151112T233237Z	SuperJed
007	Brian & Chuck	151111T095849Z	Martin E
003	DStack	151111T015644Z	DarkPhan
000	Befunge	151002T173702Z	daniero
002	Haystack	151110T175629Z	sweerpot
002	Seriously 0.1	151109T025715Z	user4594
nan	Pyth	151109T003921Z	izzyg
031	ಠ_ಠ	151106T050605Z	Mama Fun
004	PoGo	151106T000738Z	Fabian S
014	Roadrunner	151105T234443Z	Zach Gat
006	Underload	151105T201738Z	MickyT
nan		151104T133653Z	Jacob Mi
017	Hassium	151104T133344Z	Jacob Mi
054	HalfBroken Car in Heavy Traffic	151103T231745Z	anOKsqui
002	x86 Machine code	151103T213915Z	enhzflep
005	Perl 6	151103T191333Z	Brad Gil
007	PowerShell	151030T220158Z	Chad Bax
001	Minkolang	151025T203922Z	El'e
008	Univar	151025T113836Z	LegionMa
015	Gema	151009T170614Z	manatwor
005	Burlesque	151020T145857Z	mroman
010	GOLF	151020T004839Z	Liam
003	x86 Assembly	151019T214115Z	cat
010	AppleScript	151011T104953Z	Addison
048	C++ Template MetaProgramming	151011T100449Z	Nathan
061	ArnoldC	151015T234834Z	Mama Fun
017	OCaml	151002T202927Z	coredump
016	HPPPL	151013T132557Z	M L
009	PARI/GP	151013T083403Z	alephalp
002	Staq	151013T064944Z	M L
002	Cardinal	151013T063558Z	M L
002	ShadyAsFuck	151010T183318Z	Addison
003	Pyth	151009T151911Z	Grant Da
006	MIPS	151012T083545Z	user9023
018	HP48's RPL	151007T130332Z	LeFauve
006	TIS Node Type T21 Architecture	151010T021739Z	undergro
001	8085 Intel Microprocessor	151006T090743Z	Kishan K
001	><>	151002T173433Z	Fongoid
008	Coffee Script	151009T150051Z	Grant Da
019	GOTO++	151006T090108Z	Fatalize
035	Delphi	151009T114820Z	James
002	Piet	151008T195027Z	LukStorm
008	pb	151008T144854Z	undergro
106	Mornington Crescent	151006T190039Z	Fongoid
012	Emily	151007T223326Z	kirbyfan
009	Turing Machine Code	151002T202532Z	SuperJed
014	Factor	151007T181912Z	user2911
011	Emmental	151007T151631Z	ETHprodu
072	Funciton	151007T150447Z	Timwi
006	Sclipting	151007T144902Z	Timwi
014	Ziim	151007T145417Z	Timwi
004	AT&T PDP11 Syntax Assembly	151002T225339Z	Random83
004	NASM/YASM x86 assembly	151006T205912Z	Peter Co
008	R	151006T203928Z	Dason
007	Vim	151002T182223Z	daniero
010	Octave	151006T153122Z	dcsohl
002	Insomnia	151006T110009Z	n̴̖̋h̷͉̃
021	D	151006T084632Z	Kishan K
017	Rust	151006T081749Z	Liam
008	PHP	151006T073300Z	Martijn
003	MarioLANG	151005T213345Z	Martin E
003	Prelude	151005T205721Z	Martin E
020	Poslin	151005T193418Z	Thomas B
016	C	151004T221600Z	awd123
018	SmallTalk –	151005T181739Z	user1525
008	PHP	151002T182040Z	wesleyje
002	3var	151005T153642Z	Sp3000
008	Groovy	151002T200956Z	Mike Cla
011	Fortran	151005T071733Z	xebtl
030	Carriage	151005T123357Z	user2428
017	CFL 2 ComeFrom 2	151005T122212Z	user2428
003	Batch	151003T124242Z	user2428
000	Microchip PIC Machine Code	151005T092936Z	slebetma
011	Rail	151005T072309Z	Sp3000
092	SQL SQL Server 2008+	151005T015647Z	MickyT
001	z80 Machine Code	151003T223621Z	lynn
001	Labyrinth	151002T175226Z	TheNumbe
000	Aheui	151004T145459Z	lynn
007	Lazy K	151003T222145Z	lynn
009	Starry	151004T112050Z	Martin E
012	Scheme	151004T105028Z	xebtl
008	Javascript	151003T091238Z	Daffy
003	Fourier	151004T090200Z	Beta Dec
003	Pip	151004T050543Z	DLosc
004	AHK	151003T222230Z	downrep_
007	Unlambda	151003T221905Z	lynn
002	FlogScript	151003T221145Z	lynn
005	RoboTalk	151003T212710Z	Mark
002	Pyth	151002T210218Z	izzyg
009	Whitespace	151003T191653Z	Somo145
014	F#	151003T190615Z	lynn
001	Fission	151003T190528Z	Martin E
004	Perl	151003T185915Z	lynn
001	Malbolge	151003T185752Z	lynn
002	Burlesque	151003T184754Z	lynn
002	gs2	151003T184343Z	lynn
051	COBOL	151003T182811Z	lynn
015	C++	151003T182503Z	lynn
004	APL	151002T190723Z	Alex A.
031	Go	151003T165139Z	Fabian S
032	Pascal	151003T160327Z	GiantTre
002	ZX Spectrum BASIC	151003T065954Z	Radovan
021	StackStream	151003T150033Z	puckiped
017	VBScript	151003T122447Z	Kevin El
002	Recall	151002T172345Z	user4264
004	k	151003T071038Z	Alexande
016	ObjectiveC	151003T055007Z	Albert R
010	STATA	151003T053712Z	bmarks
007	ferNANDo	151003T053432Z	primo
054	C++ 11 template metaprogramming	151002T194311Z	Justin
014	A POSIX OS's program loader	151003T004409Z	user4572
014	VBA immediate pane	151003T020706Z	Mathieu
005	Basilisk	151003T003808Z	The_Bass
017	C	151002T191353Z	wendelbs
009	Python	151002T175110Z	Ruth Fra
008	JavaScript	151002T224558Z	ETHprodu
006	CoffeeScript	151002T190922Z	rink.att
009	Haskell	151002T234612Z	Grant
012	Julia	151002T203908Z	eaglgene
011	Matlab/Octave	151002T181608Z	flawr
007	HALT	151002T220423Z	Downgoat
011	Lua	151002T224257Z	Veer Sin
007	PowerShell	151002T223850Z	briantis
015	C	151002T223343Z	Mark
006	FlogScript	151002T214924Z	mbomb007
010	AutoIt	151002T213554Z	user4264
006	Perl	151002T181003Z	ThisSuit
017	Rust	151002T212805Z	Doorknob
014	Macaroni 0.0.2	151002T212046Z	Doorknob
006	Snowman 1.0.2	151002T211942Z	Doorknob
002	MSM	151002T210842Z	nimi
003	Selfmodifying Brainfuck	151002T205942Z	mbomb007
047	Ada	151002T190414Z	user_181
008	R	151002T190319Z	Alex A.
003	Math++	151002T201114Z	SuperJed
006	bash + BSD coreutils	151002T184810Z	Ben
002	Beam	151002T202105Z	MickyT
003	GNU sed	151002T180551Z	Digital
006	GNU dc	151002T181648Z	Digital
012	Swift	151002T200547Z	Najkin
036	BBC Basic for Windows	151002T200303Z	Level Ri
002	X86/X64 Machine Code	151002T195206Z	kirbyfan
001	MUMPS	151002T195028Z	senshin
005	x86 Intel Assembly NASM	151002T193219Z	nom
024	LOLCODE	151002T185840Z	daniero
012	AutoIt3	151002T192108Z	GiantTre
003	rs	151002T191046Z	kirbyfan
003	Foo	151002T190717Z	kirbyfan
012	Scala	151002T185612Z	Ben
013	Spin	151002T184800Z	user1921
006	Common Lisp	151002T184202Z	coredump
001	Hexagony	151002T183556Z	ETHprodu
004	CJam	151002T182811Z	jqkul
000	L00P	151002T180804Z	Dennis
008	Processing	151002T174217Z	user4180
003	GolfScript	151002T173425Z	Dennis
002	Pyth	151002T172702Z	Blue
006	Ruby	151002T172636Z	daniero

How dare you fuck the brain, 3 bytes

I|)

Try it online!

True, 0 1 byte

Originaly the program used to just set the program to this code shown above, but as of September 10th, that's no longer an option as the program is set to a newline (which halt the program)

This also polyglots with Reng

Setanta, 5 bytes

fan()

try-setanta.ie link

The fan function “pauses forever”.

Alternate solution, 11 bytes

nuair-a 1{}

try-setanta.ie link

'Python' is not recognized, 2 4 bytes

jsjs

hehe funny javascript refrence

It will try to search label that is next to it, and since label that doesn't exist. It will never finish.

This bascily means you can put anything next to j and will still work

EDIT 25.08.2025: The language now requiers you to add a second jump statement since if the language doesn't find the maching label, it creates the label

Try it online

Bespoke, 22 bytes

looping forever with X

Equivalent to CONTROL DOWHILE;PUSH I.

PARI/GP, 8 bytes

until(,)

The first argument is set to the default 0 (or is it gnil?), so it runs forever.

TECO, 2 bytes

<>

TECO is a remarkably concise language (that's part of what gives it its reputation for being write-only). You can turn a loop construct into an infinite loop simply by omitting the iteration count.

Just, 1 byte

instead of giving you the link to the interpreter in TIO.run. I will instead explain what does ~ do:

~ will modify the behaviour of the program. Instead of halting when reaching the end, the program will go to the beginning of the line where the tilde is (or go to beginning of the code if your code is a one-liner)

SAKO, 17 bytes

1)SKOCZDO1
KONIEC

It's possible to omit usually required STOP instruction thanks to the never-ending nature of this loop.

TeX, 9 bytes

\def~{~}~

This defines ~ to expand to itself, then run ~.

FRACTRAN, 3 bytes

1/1

Try it online!

The 1/1 means multiply by 1 forever.

Regenerate, 3 bytes

$1+

Attempt This Online!

Outputs the smallest nonzero number of repetitions of a backreference to the first capture group for which the first capture group has actually captured something. Unfortunately for the poor unsuspecting interpreter, the first capture group doesn't even exist.

CASIO BASIC (CASIO fx-9750GIII), 4 bytes

Lbl A
Goto A

BrainChild ASM, 1 byte

asm {
    jmpa
}

Hex-dump of bytecode

           0  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F
00000000: 0B                                              | .

Jumps to the location in Register B, which defaults to 0, which is the program entry.

Try It Online!

!aBF', 3 bytes

FBB

Try it online

iogii (pre-alpha), 2 bytes

@@

Sets the register to itself.

A core feature of iogii is its "circular programming", creating lazily evaluated infinite values through self-reference. Usually, that means a list with a non-self-referential head or some other such "base case", but the capacity for self-reference is more general--in this case, the program attempts to get to the bottom of a completely circular reference, forever.

x86 ELF executable, 45 bytes

Unlike the vast majority of these answers, this is a truly complete program, as in a free-standing executable program.

00000000: 7f45 4c46 0100 0000 0000 0000 0000 0100  .ELF............
00000010: 0200 0300 2000 0100 2000 0100 0400 0000  .... ... .......
00000020: ebfe 31c0 40cd 8000 3400 2000 01         ..1.@...4. ..

The guts of the program are at byte 0x20 ebfe, which is featured in another answer as the smallest NASM program. If you assemble that with NASM however, you get an executable with thousands of un-needed bytes. We can get rid of most of them using the technique outlined here. You may note that this program isn't even as big as the ELF header! This bit of executable golfing malforms the ELF header and program header so they can occupy the same bytes in the file and inserts our program into some unused bytes within the header. Linux will still happily read the header and start execution at offset 0x20 where it spins forever.

Qdeql, 8 bytes

-\=\/\//

- Enqueue a single cell with value 255
\ Loop and add two 0s to the queue
 = Move the 255 to the back of the queue
 \/ Discard the first 0
 \/ Discard the second 0
/ End loop

\ is the only interesting command here. If the front of the queue is nonzero, it enters the loop and adds two zeroes to the queue. If the front of the queue is zero, it removes the zero and skips to the matching /.

tinylisp, 13 bytes

(d f(q(x(f
(f

Try it online!

Explanation

Creates a function f that calls itself (a recursive call). However since it is a tail-call and tinylisp has tail-call optimization, this loop runs forever with no stack overflow.

AWK, 15 bytes

BEGIN{for(;;);}

Try it online!

Probably the shortest true loop. AWK will also wait forever under certain circumstances hoping for input that may never come, forcing you to kill it.

Befalse (quirkster), 6 bytes

!/!
 /

1_{1{;

Try it! (Usage: copy-paste into the code box, click Show above it, and use Step to run it step-by-step. Warning: Run will lock your browser.)

Uses two interpreter-specific tricks found here. The first one skips over the newline; the second forges a return position at the start of the program.

YASEPL, 2 bytes

?1

goes back to the first instruction, which is itself

ELVM IR, 5 bytes

jmp 0

Explanation: Jump to the first basic block unconditionally, in this case, it is the start of program.

Java (JDK), 53 bytes

class A{public static void main(String[]a){for(;;);}}

Try it online!

Yay full program requirement!

brainfuck, 3 bytes

+[]

Try it online!

Never decrement: never end.

///, 3 bytes

///

Try it online!

Any bonus points for using the language's name as source code?

Arm/Thumb/MIPS/SPARC/PowerPC assembly, 3 bytes

b 0

Which produces on my machine:

AArch64 machine code, 4 bytes

0: 14000000  b 0

Or with --target=armv7m-none-eabi gives @EasyasPi's answer.

Try compiling (not running) it online to several different machine languages here!

Thunno 2, 1 byte

⁽

Try it online! (Note: it will probably crash your browser)

Tsept v1.0, 5 bytes

Tsept is an esolang I created; it's not good at golfing since even basic tasks like storing numbers and printing strings require a lot of instructions.

This program is 5 bytes long because it has to calculate and repeatedly push the jump offset.

xDDPJ

Note: Due to a bug in the interpreter, the 'J' instruction jumps to the wrong offset (specifically the original offset plus one).

'x' clears the value in the accumulator since, at the start, it contains the interpreter's version.

'D' decrements the interpreter, and due to the aforementioned bug, it has to do it twice.

'P' pushes the accumulator onto the stack.

'J' pops a value from the stack and adds it to the instruction pointer, effectively performing a relative jump.

Desmoslang Assembly, 0 Bytes

It's an infinite loop no matter what (at least until I implement a halt instruction (which I might not even do))

(,) 8 Chars or 1.585 Bytes

(,,,,())

Grass, 3 bytes

wWw

Try it online!

Essentially just a main function that calls itself recursively.

[min]mod, 2 bytes

IS

Treats the instruction stack as an instruction and calls it recursively.

Try it!

Try it step by step!

Swift, 12 bytes

while true{}

Try it online!

Thunno, 1 byte

Actually \$ 1 \log_{256}(96) \approx \$ 0.82 bytes but the leaderboard doesn't take decimals.

Attempt This Online!

Just a simple infinite loop.

Arturo, 9 bytes

whileø[]

Try it

This also works and is the same length:

f:$[][f]f

TacO, 2 bytes

@"

TacO sees the source code as an infinite plane. When it encounters a ", it searches forever for the matching quote, idling forever. @ is required as a program root.

Try it online!

Rattle, 3 bytes

[]0

Try it Online!

Fig, \$\log_{256}(96)\approx\$ 0.823 bytes

Beats all y'alls' one-byters mwahahaha

Knight, 3 bytes

W1N

Epic W1N.

DC, 6 bytes

[dx]dx

It puts the constant string [dx] on the stack, duplicates it (d command), pops and interprets string (x command).

makina, 2 bytes

><

That's it, that's the program.

BitCycle, 3 bytes

1><

Try it online!

Explanation (because i can)

1    Creates a 1 bit, heading east by default
 >   Sets the direction to east
  <  Sets the direction to west
 >   Sets the direction to east again, creating a loop

Rust, 6 bytes

loop{}

Try it online!

That's one very fast loop

Exceptionally, 1 byte

Attempt This Online!

All programs in Exceptionally run as infinite loops. (Unfortunately, the empty program exits immediately instead of looping.) All we need is a no-op to execute each time.

Here, we're using =, which (given no arguments) asserts that the register is equal to itself. In fact, any of the characters +-*^=IF{}! should work. Several others (&UDSW) would also work, except that they will eventually run out of memory and print something to stderr.

rSNBATWPL, 1 byte

Lowkey unsure if this is a parsing bug or a feature, but it works and now I can't close the repl help please I have two unclosable tabs now Radvylf why would you do this.

Lost, 1 byte

Try it online!

Plumber, 7 bytes

[]
[[]]

This is the shortest possible infinite loop in Plumber.

Plumber programs are divided into units, which are always two characters wide (and padded to two with spaces if shorter). This one consists of three units: [], [[, and ]]. When a Plumber program is run, a 0 packet is dropped from all [] on the top row. This packet can be picked up by a ][, which pushes it to the sides.

A [[ will push it to the right, but it continues down (and is destroyed upon leaving the 2d space). Likewise, when the ]] is pushed into from either side (left in thus case), the packet is dropped and destroyed, and pushed back to the left. The [[ pushes it back to the ]], and this continues indefinitely.

Uselesslang, 0 bytes

Explanation:

<empty>
<EOF>   goto first char

KonamiCode, 12 bytes

v(^)L(>)B(>)

S(^)L(>)B(>) does the same thing but isn't shorter.

Pure CPython 3.10 Bytecode, 2 bytes

Hex:

71 00

Disassembly:

    >>    0 JUMP_ABSOLUTE            0 (to 0)

Attempt This Online!

ErrLess, 0 bytes

An empty program in ErrLess is an infinite loop! This is because if the IP reaches the end of the program it loops back to the start, so programs have to be explicitly halted using ..

ErrLess is a stack-based language I made for fun over the last few months. You can read the docs here, and I also started a tutorial.

Try it online!

Binary Pi Calculus, 6 bytes

0x73 0xB8 0x1B 0xDB 0xB0 0x00

Unfortunately, I could find no existing BPC interpreter. If one does exist, please let me know.

Explanation

0x73     0xB8     0x1B     0xDB     0xB0     0x00
01110011 10111000 00011011 11011011 10110000 00000000
01110011101110000001101111011011101100000 0000000
011                                       Run the following two processes in parallel
   100    1110                            Write the free variable 0...
      1110                                ...to the free channel 0
              000                         End first process
                 001                      Run the following on an infinite number of threads:
                    1011110               Read from the free channel 0 to the bound variable 0
                           110    1100    Write the bound variable 0...
                              1110        ...to the free channel 0
                                      000 End second process

The corresponding pi-calculus program is

a<a>|!a(a).a<a>

Reads and writes are blocking, so each thread will be executed sequentially. As there are an infinite number of them, the program will therefore never halt.

RISC-V machine code, 2 bytes

For CPUs implementing RV32I/E-C or RV64I-C:

01 a0 — c.j .

For RV32I/E-C CPUs only:

01 20 — c.jal .

RISC-V machine code (no extensions), 4 bytes

There are 4 sets of 32[1] instructions that work for this

6f 00 00 00 - j .
ef 00 00 00 - jal .
6f 01 00 00 - jal x2, .
...
ef 0f 00 00 - jal x31, .

The other 96 options are based on the conditional jump instructions beq, bge and bgeu with the same register as operands

[1]: 16 on RV32E

Aussie++, 47 bytes

G'DAY MATE!
THE HARD YAKKA FOR f IS()<f();>f();

Tested in commit 0a5de7e. The official syntax for this is:

G'DAY MATE!

I RECKON I'LL HAVE A WALKABOUT UNTIL (YEAH, NAH) <
>

CHEERS C***!

However, that UNTIL loop is so verbose it's shorter to use a recursive function.

Braingolf, 4 bytes

[1+]

Try it online!

Braingolf v2, 3 bytes

1[]

Try it online!

Vyxal, 1 byte

Try it Online!

Taxi, 22 20 bytes

[a]Switch to plan a.

Try it online!

Not very exciting. TIO will only run it for 60 seconds before timing out.

Maze, 7 Bytes

^^
%R%L

Maze is a 2D language where cars navigate through a maze and execute instructions in cells they visit. This code starts a car ^^, which by default moves downwards. The next instruction redirects the car to the right %R. That lands on a cell that redirects the car to the left %L, creating an infinite loop.

Java6 : 25 Bytes

In Java 6 and previous versions you can execute static initialization block without having main in your class file.

class A{static{for(;;);}}

Minim, 4 Bytes

C--.

Decrements the program counter, which is incremented back to 0 after the statement finishes.

GitHub Repository

Arduino, 27 bytes

void setup(){}void loop(){}

This is also the shortest Arduino code that will actually compile. I'm surprised no-one has done this yet.

StackLang, 1 byte

Explanation

2 is an opcode for infinite loop. When it reaches the bottom of the stack, it loops around.

Daoyu, 1 byte

><

Each instruction is one hex, so two instructions fit into one byte (0x69). The < increases the operating level (a number that affects certain commands) and moves the program reader to the beginning of the program, but only if the op level is less than 9. So, it's preceded by the > command, which decrements the op level (to a minimum of zero).

Mascarpone, 8 bytes

[:!]v*:!
[  ]v*   // define and push a new operation
 :!   :! // duplicate and execute the operation on the stack

h, 20 bytes

8,2,9,4,9,6,8,2,-1,0

Neither the language (by Nerdaxe) nor this answer (by VilgotanL) are my creations, but I want to publicize them here.

h (link) is a programming language created by Nerdaxe which is quite limited.

Here's an explanation of how the program works through pseudocode similar to subleq assembler:

neg1 2 #acc is now -1
zero 4 #acc is now 1, the variable zero is 1
zero 6 #acc is now 0, the variable zero is 0
neg1 2 #acc is now -1, go back to 2
neg1:-1 zero:0 #variables

yuno, 2 bytes

1¿

This will freeze your browser window so I took the TIO link out.

 ¿    While
1     1
      (1)

The 1-byter ɫ (call this link) dies to recursion which unfortunately outputs to STDERR. I might add a flag to disable that in the future.

This will keep applying 1 to 1 until 1 is not true and then print the result after infinite time. Hopefully that's acceptable. If not, you can add the d flag to disable implicit output, or do 1¿ɳ“” - evaluate 1¿, then take ignore that and take the right argument to ɳ, which is “”, an empty string.

Knight, 3 bytes

W1N

Try it online!

# pretty straightforward
WHILE 1
    # The official name for this builtin is NULL.
    # Because builtins are determined by the
    # first character, I can call it NOP.
    NOP

Locksmith, 4 bytes

0 pushes the next digit (1) to the stack, 5 acts as a label, and 6 jumps to the most recent 5 if the top of the stack is non-zero

Dis, 0 bytes.

Yes, a blank program:

How it works

The Dis language accepts an empty program.
Begins with c=0.
mem[i]=0 for each i, so every cells stand for NOP.
Unlike Malbolge, the Dis language does never modify the program by default.
This goes forever.

Since TIO doesn't have Dis by native, I made the interpreter. Try it online!

Elixir, 38 18 bytes

l=&[&1.(&1)];l.(l)

Try it online!

l=&[&1.(&1)];l.(l)  # full program
 =          ;       # set...
l                   # variable...
 =          ;       # to...
  &[       ]        # function taking one argument that...
      .(  )         # calls...
    &1              # first argument...
      .(  )         # with argument...
        &1          # first argument
              .( )  # call...
             l      # variable...
              .( )  # with argument...
                l   # variable

x86 machine code - 2 bytes

 6                                  .loop:
 7 00000000 EBFE                        jmp     .loop

This is a same code as :

 6 00000000 EBFE                        jmp     $

x86_16 machine code - 2 bytes

 12 0005  EB FE              JMP     $

Tested on DOSBox

MMIXAL, 10 bytes

Main JMP @

Assembly language. Has jump-to-self. Done. (This compiles down to four bytes of actual code, F0000000.)

Splinter, 5 bytes

A{A}A

Try it online!

Interpreter crasher. Defines A as itself, then calls A, with infinite recursion.

Jellyfish, 5 bytes

\>1
1

Try it online!

jellyfish doesn't have implicit output, so nothing is printed here.

Explanation

given with positions.

(0,0) \ iterate the following function: 
(1,0)  >  increment 
(0,1) 1 on one
(2,0) till 1 is reached.

C(gcc, platform-independent), 17 bytes Highschooler here, finally something I can do.

main(){for(;;){}}

I read somewhere that this is the least bytes for an infinite loop, although I'm not sure.

CSASM v2.4.0.2, 26 bytes

func main:
.lbl a
br a
ret
end

Endlessly jumps execution back to the label a, which just refers to the br instruction itself.
The ret instruction and end token are needed for the function to compile.

ABC, 2 bytes

al

l is the actual infinite loop, a is just a placeholder to increment the accumulator at each iteration.

Try it online!

Duocentehexaquinquagesimal, 2 bytes

2º

Try it online!

Scratch, 23 bytes

A "forever" block still runs when it's empty.

when gf clicked
forever

convey, 2 bytes

5]

Try it online!

In convey, } is an output, and ] is a dummy output or sink. In convey, all static numbers and strings continuously output, so 5] will continuously output 5 to a dummy output, looping forever.

BRASCA, 3 2 bytes

1J

Try it!

Explanation

1J - Move the pointer back one character.

Pxem, Filename: 4 bytes + Content: 0 bytes = 4 bytes.

Filename: .w.a
Content: none

Prolog, 5 bytes

a:-a.

In order to know if predicate a is true, you only need to check if predicate a is true.

_{You need to load the file and execute a, both with a command-line arguments, eg. swipl -g a a.pl with Swi-Prolog. Note that the recursion is likely to be optimized as an infinite loop and shouldn't blow the stack.}

Also, this looks like a smiley, but I am not sure how to call it. The dot looks like saliva, so maybe "vegetative state", or "Infiurated programmer with curly hair". Suggestions are welcome.

Edit: I look at the rules again and for a full program and no command line arguments you need to add this, as user @radrow pointed out, for a total of 10 bytes.

a:-a.
:-a.

Alternatively, for 14 bytes you can have something more poetic:

:-repeat,fail.

Python 3, 14 bytes

{*iter(int,1)}

Try it online!

vJASS (Warcraft 3), 58 bytes

//! inject main
loop
endloop
//! dovjassinit
//! endinject

Without exitwhen inside the loop, it loops infinitely.

Canvas, 2 1 byte

⁹

Try it here!

⁹ redirects execution to the main program. This means the program contains a call to itself, so it runs forever.

Racket, 39 bytes

((λ(x)(x x))(λ(x)(x x)))

Factor, 10 bytes

[ t ] loop

Try it online!

Factor is not necessarily verbose :P

Given that we need a quotation to repeat and a looping word, I believe this is the very shortest we can get in Factor.

ARM Thumb-2 machine code, 2 bytes

e7fe

1:
        b.n     1b

It is an instruction that jumps to itself. There isn't much else to it.

Being a single narrow instruction, it is the shortest possible solution.

C (GNU-EFI), 0 bytes

Yes, a C GNU-EFI program won't exit. You need to return for it to exit. Will not say anything, just hang.
And yes, it works with a standart GNU-EFI Makefile.
I used this one:

ARCH            = $(shell uname -m | sed s,i[3456789]86,ia32,)

OBJS            = main.o
TARGET          = main.efi

EFIINC          = /usr/include/efi
EFIINCS         = -I$(EFIINC) -I$(EFIINC)/$(ARCH) -I$(EFIINC)/protocol
LIB             = /usr/lib
EFILIB          = /usr/lib/
EFI_CRT_OBJS    = $(EFILIB)/crt0-efi-$(ARCH).o
EFI_LDS         = $(EFILIB)/elf_$(ARCH)_efi.lds

CFLAGS          = $(EFIINCS) -fno-stack-protector -fpic \
          -fshort-wchar -mno-red-zone -Wall
ifeq ($(ARCH),x86_64)
  CFLAGS += -DEFI_FUNCTION_WRAPPER
endif

LDFLAGS         = -nostdlib -znocombreloc -T $(EFI_LDS) -shared \
          -Bsymbolic -L $(EFILIB) -L $(LIB) $(EFI_CRT_OBJS)

all: $(TARGET)

main.so: $(OBJS)
    ld $(LDFLAGS) $(OBJS) -o $@ -lefi -lgnuefi

%.efi: %.so
    objcopy -j .text -j .sdata -j .data -j .dynamic \
        -j .dynsym  -j .rel -j .rela -j .reloc \
        --target=efi-app-$(ARCH) $^ $@

Hope this counts. And yes I tested this on a virtual machine.

Vyxal, 1 byte

Try it Online!

-3 thanks to answering the right question

Explained

{      # Start an infinite while loop

Perl 5, 6 bytes

{redo}

Try it online!

C#9, 8 bytes

for(;;);

In C#9, they introduced Top-Level Statements which means one source file no longer needs any boilerplate.

Pixilang, 8 bytes

a:goto a

A pixel based programming language.

Arn, 3 bytes

[[{

Try it!

Takes advantage of Arn's pretty printing of matrices combined with an infinite, empty sequence.

Forth (gforth), 15 bytes

[begin] [again]

Try it online!

Shortened nonForgivingJesus's answer using square brackets for looping directly.

My first Forth answer!

NDBall, 11 bytes

(0)>0
(1)<0

the ball bounces back and forth forever

the ball starts on (0) then is told to move forward along the 0th dimension making it go to (1)

then at (1) it is told to move backward along the 0th dimension, making it go back to (0)

the new line is mandatory, hence the extra byte

this was done in NDBallSim V1.0.1

Poetic, 10 bytes

why i
o no

Try it online!

AWK, 15 bytes

BEGIN{for(;;)1}

The smallest code that doesn't look for input.

I tried without the 1 and AWK wasn't happy.

Try it online!

sed, 3 bytes

:;b

Pretty simple. Make an unnamed label, then branch to it. Not all versions of sed support unnamed labels, in which case there is a 5 byte solution.

:a;ba

Marbelous, 8 bytes

@0
00
@0

Marbelous is a language based on marble machines

@n (n from 0 to Z) is a portal which teleport the marble to another portal with the same value
00-FF initiate a marble with this value

interpretor

International Phonetic Esoteric Language, 3 7 4 bytes

01ɑɒ
10   (loop bounds 0-1, set current IDX=0, LIM=1)
  ɑɒ (since IDX<LIM, infinite loop)

7 bytes. Labels are fun.

|a|ʟ|a|

Defines a label a and jumps to a.

3 bytes (WIP language) (OLD)

ɘ0e

What the code does is push 0, then check if the stack is falsy, which 0 is. Then it jumps, without any output.

No TIO interpreter yet, but is runnable by cloning the repository above, and calling python3 main.py "code here".

ɘ0e
ɘ   ; begin falsy jump
 0  ; push 0
  e ; pop, if falsy jump; else end falsy jump

05AB1E, 1 Byte

Try it online!

[  # begin infinite loop

ezfuck, 2 bytes

+{

Basically equivalent to +[] in BrainFuck.

+ increments the current cell to 1, then { jumps back a single command while the current cell is non-zero.

Add++, 5 bytes

Dx,+1

Try it online!

Very basic, this simply executes the following pseudocode:

x = 0
Do
  x = x + 1
While x > 0

For 1 extra byte, we can remove any possibility of running out of memory if x becomes too big:

Dx,x:1

Try it online!

which simply sets x equal to 1 each time, rather than x+1

Rockstar, 17 9 bytes

while 1
1

Try it here (Code will need to be pasted in)

Haskell, 8 bytes

main:x=x

One byte shorter than the classic main=main.

Flurry `-nnn`, 10 bytes

(<>{}{}){}

Try it online!

Don't be afraid to click Run; it will stop immediately, complaining the program didn't finish in 10000 steps. Change the step limit and you can see that it is reducing into the same expression over and over. Running in the original Haskell interpreter actually runs an infinite loop.

While Flurry looks like Brain-Flak, it lacks explicit looping support. Instead, because it is functional and primarily designed with combinators, we can implement the Omega combinator S I I (S I I), which endlessly reduces to itself.

The nilad <> evaluates to S and {} pops an item from the stack. When the stack is empty, I is popped. The monad (f g h...) evaluates f g h... as function application, and pushes the result to the stack.

(<>{}{}){}  Full program
 <>         S
   {}       I
     {}     I
(      )    Evaluate to (S I I) and push it to stack
        {}  Pop (S I I)
            The entire program evaluates to (S I I)(S I I) = Omega

Python 3, 15 bytes

def f():f()
f()

Try it online!

A function calling itself (till maximum recursion depth exceeded)

MAWP v1.1, 2 bytes

[]

Stack starts with 1, brackets loop as long as top of stack isn't 0.

Try it!

Integral, 6 Bytes

⌡◙d⌡◙d

Don't Try it! (it will screw up your browser)

Brainetry, 41 bytes

The 41-byter is a golf of this Brainetry program with 133 bytes:

This program is useless.
This program is useless because it runs forever.
This program is useless because it does absolutely nothing.

and the golfed version:

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

Rust, 18 bytes

fn main(){loop{}}

Thankfully loop exists :) , recursion causes a stack overflow plus its the same amount of bytes.

Ruby, 6 bytes

The loop construct produces an infinite loop. Thanks, Yukihiro Matsumoto.

loop{}

J, 5 bytes

-^:]_

Try it online!

-        Negate the given number
 ^:]     Repeat (right arg) times
    _    The right arg: infinity
         Repeat (infinity) times means to find the fixed point,
         but there is none since it alternates between _ (inf) and __ (-inf)

0&-~_

Try it online!

0&-~_    `~` gives the argument `_` to both sides of `0&-`
         so it is equivalent to `_ (0&-) _`
_ (0&-) _
  (0&-)      Negate the given number
_            If you give left arg to a `&`-function, it becomes repeat count
             so it acts exactly like `^:_` (find the fixed point)
        _    The initial value

This one works with any other single-digit integer in the place of 0.

Haskell, 9 bytes

main=main

Defines the main function (required to run) recurring on itself, resulting in an infinite loop.

TI-BASIC, 4 Bytes

Written in TI-BASIC for TI-83 or 84 series.

While 1:End

Previous version, 5 Bytes

Lbl A:Goto A

I like frog, 13 bytes

frog like i

frog like says that it is going to based off the parameters, go back 1 instruction (which is this instruction, creating a loop) i is the parameter saying how many instructions to go back.

J, 6 bytes

<^:_[1

Try it online!

Explanation

<      # A monad
 ^:_   # Done infinity times
    [1 # To an argument

Husk, 2 bytes

LN

Try it online!

Explanation

 N   The natural number list       . [1, 2, 3, 4, ...]
L    Try to find the length of that. ???

     Weirdly, Husk isn't lazy in this case.
     So it will loop forever as the
     counter approaches positive infinity.

Kotlin, 14 bytes

{while(1>0){}}

Try it online!

W `i`, 1 byte

Forever, execute the input (which is then not printed to the console).

W `i`, 4 bytes

Pretty much a terrible language for looping.

i""E

Explanation

i   E % Foreach the range from 0 to positive infinity:
 ""   % Push the null string

Flags:i  % Implicit print disabled
```

Taktentus, 4 bytes

_:=0

This is jump for line number 0 (first)

In English: https://esolangs.org/wiki/Taktentus

tq, 3 bytes

"")

Explanation

"",  # Define an empty string
   ) # Extend the list forever

Intcode, 5 bytes

5,0,1

This is too short.

><>, 0 bytes

Explanation

There's no ; instruction to halt the program, so it runs forever.

QWOP, 2 bytes

OO

Explanation

The command O return[s] the pointer to the last O, if one exists. So this will run indefinitely without producing output.

///, 3 bytes

///

Try it online!

Explanation

This replaces nothing with nothing. It runs forever because when it replaces nothing with nothing, it has to replace that nothing with another nothing, and it does this indefinitely.

NULL, 2 bytes

Code in the NULL language is a number.

The interpreter sets X = 41 and Y = 1. Afterwards, it divides X by its smallest prime factor (41) and multiplies Y by that, so then X = 1 and Y = 41.

Afterwards, it performs an action which corresponds to that prime factor. The action for 41 is to swap X and Y, so X = 41 and Y = 1.

The program ends when X = 1, which will never happen with this code.

Whenever: 4 bytes

1 1;

Is actually an example from the specification. The instruction causes line 1 to put itself back on the to-do list.

Nandy, 4 bytes

:#()

Never decrement: never end. (0 NAND 0 is 1. Thanks to @EdgyNerd for noting that.)

1+, 5 bytes

1##1#

Explanation:

1#    [Jump to 1st hash]
  #   [1st hash in program (counting starts from 0)]
   1# [Jump to 1st hash]

Alternatively, 5 bytes

(|())

Explanation:

This program define and execute a function with an empty name. The function calls itself. Thus, it is infinite recursive.

PHP, 12 bytes

Different answers are posted for PHP which use loops or labels, but here is one which doesn't use any of them. Save the file with a single character name and then include itself. For example if you save the file as 1:

<?include 1;

Run with: php -n 1, this will go on until PHP goes out of memory or max execution time reaches.

Cascade, 1 byte

Try it online!

or (if my understanding is correct) any other one-byte program from @/\!^?_$<>=~+-*:%().#--that is, any instruction which depends on the return value of what's below it, either directly or to the left or right, since in the case of a one-byter all three of those wrap back around to the same command. I suspect that most if not all of these would run out of call stack given enough time, but I don't know Perl so I can't quite tell what the interpreter is actually doing.

Rust, 17 bytes

fn main(){loop{}}

Just for fun :P

Element, 3 bytes

!{]

Negates top of stack & executes while.

TIO

Kipple (cipple), 6 5 bytes

1>a(a

Pretty simple, just pushes 1 to stack A, and then begins a loop that only ends if stack A is empty

-1 byte, since the ending bracket isn't necessary in cipple for some reason

Try it online!

Pyramid Scheme, 41 bytes

   ^
  / \
 /do \
^-----^
-^    -
/1\
---

Try it online!

Almost a straight translation of @JoshuaTaylor's Lisp ten-byter.

Pizza Delivery, 2 bytes

(]

While L is zero, end while.

@, 2 bytes

¤

Loops forever, takes arbitary input and has no output.

Fastlane, 0 bytes

The pointer speed defaults to 1 and wraps around; there isn't a $ instruction to halt the pointer in this program.

A0A0, 2 bytes

G0

Goes 0 lines below the current line.

And, 0 bytes

No && exit, therefore loops forever.

ABC (Esoteric), 1 byte

Loops back to the beginning.

Stax, 1 bytes

Run and debug it

G goes to the beginning of the program...

x86-16 Assembly, IBM PC DOS, 2 bytes

There's quite a few machine code answers, but thought I'd contribute a few different takes.

56    PUSH SI    ; push 100H onto stack
C3    RET        ; pop stack and jump to address (PUSH SI)

On DOS when a program is started the SI register contains the starting address of the program (generally 100H). Push that onto the stack and execute a RET which will pop the stack and jump to that address. Big ol' loop.

x86-16 Assembly, 1 byte

F4   HLT         ; halt the processor and wait for signal

Okay, so this may depend a little on your definition of infinite loop. The HLT instruction (specifically in 8086 real mode) puts the processor in HALT state and awaits a signal in the form of BINIT#, INIT#, RESET# or interrupt (ref). While it's not technically executing our code, it is in a microcode loop of sorts waiting for one of those signals.

Motorola 6800, 2 bytes

9D DD   HCF      ; halt and catch fire

From Wikipedia:

When this instruction is run the only way to see what it is doing is with an oscilloscope. From the user's point of view the machine halts and defies most attempts to get it restarted. Those persons with indicator lamps on the address bus will see that the processor begins to read all of the memory, sequentially, very quickly. In effect, the address bus turns into a 16 bit counter. However, the processor takes no notice of what it is reading… it just reads.

Oasis, 2 bytes

1b

TIO

Explanation

1  Starting from a(1)
 b Recurse all the way down (i.e. do a(n-1))

jq -n, 9 + 3 = 12 bytes

def f:f;f

The -n option makes jq not consume any input, otherwise it waits for stdin before starting the loop.

GOLANG : 32 Bytes

package main;func main(){main()}

One more solution :

package main;func main(){for{}}

Malbolge, 1787 bytes

This one doesn't rely on interpreter bug.

bP&A@?>=<;:9876543210/.-,+*)('&%$T"!~}|;]yxwvutslUSRQ.yx+i)J9edFb4`_^]\yxwRQ)(TSRQ]m!G0KJIyxFvDa%_@?"=<5:98765.-2+*/.-,+*)('&%$#"!~}|utyrqvutsrqjonmPkjihgfedc\DDYAA\>>Y;;V886L5322G//D,,G))>&&A##!7~5:{y7xvuu,10/.-,+*)('&%$#"yb}|{zyxwvutmVqSohmOOjihafeHcEa`YAA\[ZYRW:U7SLKP3NMLK-I,GFED&%%@?>=6;|9y70/4u210/o-n+k)"!gg$#"!x}`{zyxZvYtsrqSoRmlkjLhKfedcEaD_^]\>Z=XWVU7S6QPON0LKDI,GFEDCBA#?"=};438y6543s1r/o-&%*k('&%e#d!~}|^z]xwvuWsVqponPlOjihgIeHcba`B^A\[ZY;W:UTSR4PI2MLKJ,,AFE(&B;:?"~<}{zz165v3s+*/pn,mk)jh&ge#db~a_{^\xwvoXsrqpRnmfkjMKg`_GG\aDB^A?[><X;9U86R53ONM0KJC,+FEDC&A@?!!6||3876w4-tr*/.-&+*)('&%$e"!~}|utyxwvutWlkponmlOjchg`edGba`_XW\?ZYRQVOT7RQPINML/JIHAFEDC&A@?>!<;{98yw5.-ss*/pn,+lj(!~ff{"ca}`^z][wZXtWUqTRnQOkNLhgfIdcFaZ_^A\[Z<XW:U8SRQPOHML/JIHG*ED=%%:?>=~;:{876w43210/(-,+*)('h%$d"ca}|_z\rqYYnsVTpoRPledLLafIGcbE`BXW??TY<:V97S64P31M0.J-+G*(DCB%@?"=<;|98765.3210p.-n+$)i'h%${"!~}|{zyxwvuXVlkpSQmlOjLbafIGcbE`BXW??TY<:V97S64P31M0.J-+G*(D'%A@?"=<}:98y6543,1r/.o,+*)j'&%eez!~a|^tsx[YutWUqjinQOkjMhJ`_dGEaDB^A?[><X;9U86R53O20LKJ-HG*ED'BA@?>7~;:{y7x5.3210q.-n+*)jh&%$#"c~}`{z]rwvutWrkpohmPkjihafI^cba`_^A\[>YXW:UTS5QP3NM0KJ-HGF?D'BA:?>=~;:z8765v32s0/.-nl$#(ig%fd"ca}|_]yrqvYWsVTpSQmPNjMKgJHdGEa`_B]\?ZY<WVUTMR5PO20LK.IHA))>CB%#?87}}49zx6wu3tr0qo-nl*ki'hf$ec!~}`{^yxwvotsrUponQlkMihKIe^]EEZ_B@\?=Y<:V97S64P31M0.J-+GFE(C&A@?8=<;:{876w43s10qo-&%kk"'hf$ec!b`|_]y\ZvYWsVTpSQmlkNiLgf_dcba`C^]\?ZY;WV97SLK33HM0.J-+G*(D'%A$">!};|z8yw543t1r/(-,+*)(i&%fd"!~}|_t]xwvutslqTonmPkjLhKIeHFbEC_^A?[TSX;9UT7R4JIN1/K.,H+)E(&B%#?"~<}{987x/4ussr).o,+l)(h&ge#db~a_{^\x[YutWrTjinQOkNLhgJeG]\aDB^]@[=SRW:877LQP3N0FEJ-+**?DC&A#98=~|:98yx/4u21rp(',mk)(ig%|{"ca}`^z][wZXtWUqTRnQOkNLhKIedcFE`YB@@?ZYRW:UTS6QPO11F..CHGF)(CB;@#>!~;XzV7gwu-QrrqMoJIkZF'WC$#AbQ`_{^L9wI64"VDConzl+j);JJ%qGFEZ~}]{ygwRuc8aSq44"H1Y.iV,e*RQ

Try it online!

Forget, 37 bytes

const 0x0 1;cleanse 0x0;while 0x0;end

TIO

Forth, 19 bytes

: b begin again ; \ compiles word that loops endlessly
b                 \ executes this word

Try it online!

33, 4 bytes

Yes, this is a very simple answer:

1a[]

Nothing short of outright hardware failure will stop this from running. Or, y'know, stopping the program.

Backshift, 1 byte

How it works

This tries to move 0 1-0=1 times backwards. This does not halt, as it tries to do this until it encounters a 1 (which is impossible).

Adar, 7 bytes

[(0,1)]

How it works

This is a looping counter; that means it starts from 0 and counts up in 1s forever.

Turing Machine But Way Worse, 27 13 bytes

0 0 0 1 0 0 0

Try it online!

Explanation:

Rest of the number isn't necessary, as they are text-based and pointer commands.

0 0 0 1 0 0 0-> do not halt
  |     | |
  |     | +-> do not print
  |     +--> go to state 0
  |
  +---------> if state 0

VTL-2, 7 bytes

2 #=1

# is the system variable in VTL-2 for line numbers, and it works to retrieve a line number or as a GOTO if given an assignment. So this is a trivial GOTO loop. The one interesting thing about it is that VTL-2 doesn't actually let you GOTO the current line number. It does GOTO the next largest line number when given a nonexistent line, however, so a one-line infinite loop will always work given that y is less than x for the program x #=y.

Aheui, 0 byte.

Since Aheui is befunge-like, this is infinite loop.

Brian & Chuck, 7 bytes

!{?
!{?

Try it online!

Keg, 1 byte

Auto completes the while loop and runs it infinitely

Stack Cats `-m`, 5 4 bytes

{>}I

Try it online!

-1 byte thanks to negative seven

        Since there is no input, the stack starts with nothing but -1 on the top.
{       Remember the current value on top of the stack, and loop:
 >      Move the head right on the tape of stacks. (All of them are filled with zeroes.)
  }     Repeat while the top of the stack is not as it was remembered.
   I    Since the loop goes on forever, this is just to make the program legal.

TIS-100, 0/5 bytes

Nonempty solution:

JRO 0

It's really hard to tell the difference between "halting" and "repeating infinitely" in TIS-100, since every program loops automatically. As such, I have done both an empty and nonempty solution.

Crystal, 6 bytes

loop{}

The loop keyword takes a block, which is here denoted by the curly brackets. I'm not sure I've seen any "real" (intended for use) Crystal code that uses loop instead of while, but I'd expect it to be used in the expanded form:

loop do
  # do something here
end

Flobnar, 1 byte

Try it online!

@ indicates the entry point of a program and evaluates the cell to its west. There is nothing to the west, meaning it wraps around and evaluates @ again.

The language spec is unclear about whether it is legal for @ to evaluate itself recursively. The linked interpreter supports it. It also does tail-call elimination, meaning that this is really an infinite loop and will not cause a stack overflow.

INTERCAL, 16 bytes

(1)DOCOMEFROM(1)

Try it online!

Probably the first time I've managed to get away with not GIVING UP. This program goes to line 1 after line 1 finishes executing. (The shorter (1)DO(1)NEXT very quickly maxes out the NEXT stack and disappears into the black lagoon.)

Commodore BASIC V2 (Commodore 64/VIC-20), 6 tokenized BASIC bytes

 0 GOTO

or to save some typing (not actual bytes):

 0G[shift]O

which uses the keyword abbreviation for GOTO (may also be typed as GO TO)

In Commodore BASIC V2, GOTO assumes GOTO 0. Byte count is determined from PRINT FRE(0) on VIC-20, default value is 3581.

ink, 7 bytes

-(i)->i

Try it online!

Idris, 19 bytes

main:IO()
main=main

Haskell solution + type signature.

Tamsin, 10 bytes

main={''}.

Try it online!

Shakespeare Programming Language, 61 bytes

,.Ajax,.Act I:.Scene I:.[Exeunt][Enter Ajax]Ajax:Let usAct I.

Try it online!

It's totally legal to only ever use one character in a play; just don't make him do anything other than loop the program forever, exiting and entering the stage constantly.

Piet, 0 bytes

An empty image will make Piet loop around forever...

Chef, 75 52 46 bytes

Saved 23 bytes thanks to @Sp3000

L.

Ingredients.
1 i

Method.
X i.M until xed.

Try it online! (if you dare)

Basically, this program repeatedly checks that i (always 1) is greater than zero, and while it is, Ms the empty mixing bowl. ~~I tried to stick to the original spec as much as possible, so it may be able to golf this even more.~~ Thanks to TIO, I can now verify my changes with a copy of the interpreter!

Lua, 9 bytes

Here are all of the different ways (that I know of) to make an infinite loop in Lua, from shortest to longest:

Goto loop (Lua 5.2.0 beta-rc1 only) at 9 bytes:

@a:goto a

This is no longer possible in the latest version of Lua since the syntax for goto has changed, so this is now the shortest infinite loop at 11 bytes:

::a::goto a

The best that you can do using a while loop is 13 bytes by using an empty string, which Lua considers to be truthy, as the conditional:

while""do end

Here is a 14 byte repeat until loop using an uninitialized variable, which is always nil, as the conditional:

repeat until a

Tied with the return until loop, as well as my personal favorite, a recursive function using load() at 16 14 bytes: (-2 bytes thanks to Jonathan French)

f=load"f()"f()

An infinite for loop made by Jo King at 18 bytes:

for _=1,1,0 do end

Finally, the longest of the methods that I know of, a normal recursive function at 22 bytes:

function f()f()end f()

I'm curious to see if anyone can find some other methods.

µ6, 1 byte

@+

Try it online!

Explanation

The µ-operator takes a function and returns the least \$n\$ that results in a \$0\$ and since there is no \$n\$ such that \$n+1 = 0\$ this program won't terminate:

@   -- µ-operator applied to
 +  -- | successor function

Lost, 0 bytes

Try it online!

Another 2D language with a zero byte answer. Funnily enough, the minimum byte count to terminate consistently is 5 bytes:

%@
//

Try it online!

Pepe, 6 bytes

REEReE

Try it online!

Begin loop, end loop. No need to explain it much.

Also, for fun: REE ReE reeE makes the permalink #FBI.

JavaScript (Node.js), 9 bytes

while(1);

Try it online!

Z80Golf, 1 byte

00000000: c3                                       .

Try it online!

A jump opcode. Since memory is padded with zeroes, the argument is $0000, so that the PC forever jumps from $0000 to $0000.

LOLZ, 9 Characters

lolloolol

lol: creates the loop statement

loolol: returns the value "1"

TI-BASIC, 4 Bytes

While 1
End

Also:

Lbl A
Goto A

This last language isn't really an answer, as the language does not exist… yet. So, yeah, just some information, and how one might accomplish this task

Simplex, 1 Byte

Simple enough. Simplex has the O command, which goes to the _N_th character in the source code, with N being the current byte. Since, by default, a byte is 0, this continues to go to the first character in the source code (zero-based).

TI-BASIC, 2 bytes

If recursion is allowed (is it a loop?)

prgmA

Runs a program named 'A', hence the program must be named the same. Some research revealed that prgm is 1 byte, plus 1 byte for A

Runs out of memory pretty quickly, but that doesn't seem to be addressed above.

HadesLang, 15 bytes

while[true]
end

Z80 Machine Code, 1 Byte

0x76

Halt

When a software HALT instruction is executed, the CPU executes NOPs until an interrupt is received (either a nonmaskable or a maskable interrupt while the interrupt flip-flop is enabled)..

beeswax, 3 bytes

O_O

or alternatively

j_j

>_<

All three create two bees that get reflected back and forth indefinitely.

Ahead, 1 byte

l turns the head left 45 degrees. Since the board is 1x1, the head will keep trying to move but go nowhere. The head never stops until it encounters a @, so this "loops" forever.

I figured this would be more interesting than the alternative solution, one space character.

Q'Nial7, 22 bytes

WHILE =1 DO 1 ENDWHILE

DUP, 6 bytes

[1][]#                            {infinite while loop}

This is a proper and implementation independent solution. Mama Fun Roll’s 2 byte solution only works with the quirkster Javascript implementation that behaves a bit strangely in some cases.

C (gcc), 16 bytes

main(){for(;;);}

Try it online!

Tcl/Tk, 0 bytes

Execute any empty file with the wish interpreter instead of tclsh.

Gol><>, 0 bytes

Try it online!

Just for completeness. This works just like zero-byte Befunge infinite loop.

Javascript, 8 bytes

for(;;);

An empty for with no condition does the trick.

C (tcc), x86_64, 10 bytes

main=-277;

Try it online!

How it works

This writes the int -277 (ebfeffff in little endian) to the memory location of main.

eb is JMP and is to be followed by a signed 8-bit address indicating where to jump to. fe is -2, so we jump back to eb and start over.

MachineCode, 5 4 bytes

ebfe

This executes the machine code EB FE (JMP -2); -2 (0xFE) is the length of the instruction.

Try it online!

VBA 7 Bytes

Do
Loop

I like VBA; it does exactly what you tell it

Beatnik, 8 bytes

K A XX K

Push a number, 1 in this case. Pop a number, if not zero skip back 4(crossed out 4) 5. There seems to be an issue with the interpreter so we need to skip back 5 instructions rather than 4.

Of course the example on the esolangs page is better.

Ha, an interminable line!

or my version

Start a neverending tale?

mIRC v.7.49, 18 16 13 bytes

y while (1) y

This produces an infinite loop when no input is given.

The code is written in the mirc alias window, and to use it, just write /y in any chat window or status window. Also note that mIRC freezes when an infinite loop is encountered.

Japt, 1 byte

Assumes an unlimited call stack.

ß

Test it

Forth, 21 bytes

Unfortunately, you can't make a word that calls itself without using the keyword recursive, so I use a standard infinite loop instead.

: f begin 0 until ; f

Try it online

Reflections, 5 bytes

v\
\/

Test it!

Explanation:

v reflects the IP down
\ reflects the IP right
/ reflects the IP up
\ reflects the IP left
v reflects the IP down into the loop again

ORK, 132 bytes

There is such a thing as a y.
A y can z.

When a y is to z:
I am to loop.

When this program starts:
I have a y called X.
X is to z.

Try it online!

Defines a class y with a member function z that does nothing but loop. Then instantiates y and calls its z function.

Dreaderef, 5 bytes

1 9-1

Try it online!

Explanation

deref 9 -1 ; put value of cell 9 (initially 0) into cell -1, the instruction pointer

The 9 could have been replaced with any integer except -1, 0, or 2.

Python 3, 37 bytes

Hope I did this correctly

try:
    while 1:pass
except:pass

Try/Except will end program when memory runs out.

Sceql, 3 bytes

Make the current byte non-zero, then loop forever. I use this implementation to verify it.

-\/

So I suppose I can create a new language and develop its intepreter for this answer, can't I?

Feel free to use a language (or language version) even if it's newer than this challenge. -Note that there must be an interpreter so the submission can be tested. It is allowed (and even encouraged) to write this interpreter yourself for a previously unimplemented language. :D

Ghrvy...!, 3 bytes

grv

Intepreter written in Python 3

Explanation first (Syntax and functions please see below)

g            # Add 1 to the 1st cell
 r           # Loop when 1st cell != 0
  v          # Switch between cell manipulation and pointer manipulation
             # Implicit end of loop. Since 1st cell is still 1, voilà, infinite loop.

Ghrvy...! is a new programming language developed just after I finished golfing my answer in the challenge Non discriminating programming that I at first typed a lot of ghrvys in the code to meet the requirements. Since it is inspired by brainfuck, it is also the type of cell-pointer esolang. All programs in brainfuck can be transpiled to this language.

Syntax:

`g`: aGaru  - increase the pointer / value in current cell by 1.
              Affects the value by default.
              (Japanese for 'going up')
`h`: Heru   - decrease the pointer / value in current cell by 1.
              Affects the value by default.
              (Japanese for 'becoming less')
`r`: Repeat - repeat the next code block (block with indent 
              greater than the indent of the line where the `r` 
              token is on) if r is the last command of the same 
              line, or else repeat the remaining code on the same 
              line, when the value in current cell is non-zero.
`v`: Value  - switch the target of tokens `g` and `h` between the
              pointer and the value at the pointer.
`y`: Yee    - Set the value in current cell to a random number in
              the range [0, value in next cell] inclusive.
`.`: Input  - Get a byte from user input and set the value in
              current cell to that byte. Supports UTF-8.
`!`: Output - Output value in current cell as a byte in UTF-8. 
              The program will wait for a valid UTF-8 
              representation to output.
Spaces(` `) - No meaning when between commands on a line, act as
              indentation when at the beginning of a line.
Newlines    - Split code blocks, no meaning.

Since there must be something after the token r and token v does no pointer , cell and I/O manipulations, the program grv can be transpiled to brainfuck as +[].

Messages in the STDERR generated are those generated by the intepreter. No actual output is generated by the Ghrvy...! program itself.

Well, I came up the idea of the language first, and found this challenge may be a good place to show the features ;)

Pain-Flak, 8 bytes

))((})({

Try it online!

Explanation:

))(( pushes 1 on stack
})({ the }...{ loops until TOS = 0 and the )( makes it run as a loop because without the )( the }...{ would eval as }{ and not loop
The code is flipped and added to the end during Pain-Flak interpreting and the code does a infinite loop again.

Retina, 10 bytes

I'm pretty sure this can be made shorter.


0
+T`d`10

Clojure, 9 bytes (old 15 bytes) thank to @Dennins

(while 1)

Wumpus, 0 bytes

Try it online!

Another 0 byte 2D entry. In Wumpus, ~~the first cell is implicitly created,~~ the pointer is always out of bounds, so it reflects forever.

PHP 7, 8 bytes

for(;;);

This is the shortest I could think of, it's one shorter then

while(1);
//and
a:goto a;

Try it online

it's 5 more if you count the <?php tag

Visual Basic .NET (.NET Core), 44 bytes

Declare Subroutine that takes no input and loops forever.

Module M
Sub Main
Do
Loop
End Sub
End Module

Try it online! A version that outputs 1 infinitely may be seen here.

MY-BASIC, 12 bytes

Anonymous While loop that loops forever.

While 1
Wend

Try it online! A version that prints 1 infinitely may be seen here.

Yabasic, 7 bytes

Anonymous Function that takes no input and loops forever.

Do:Loop

Try it online! A version that infinitely outputs 1 may be seen here.

VBA, 7 Bytes

Anonymous VBE immediate window that takes no input and loops forever

Do:Loop

uBASIC, 7 bytes

1Goto1:

Try it online! Version that produces output may be seen Here

axo, 1 byte

Try it online!

_  goes to the command at 0,0, which happens to be _

Stax, 1 byte

Try it online!

Just an unconditional loop without body.

FALSE, 5 bytes

[1]$#

Explanation:

[ {function start}
 1 {push 1}
] {push function}
$ {duplicate}
# {while loop: pop two functions, run them while the first returns true}

This will quickly use up memory since the body function of the while loop pushes a value which is never popped.

Here's one of the same size which doesn't cause a memory leak, but only works on certain interpreters/compilers:

[1]1#

The second 1 is read as a function pointer, which causes the while loop to jump to the ], skipping the other 1.

Chip-8, 1 byte

0x12

Instructions in Chip-8 are 2 bytes, so 0x12 is interpreted as 0x1200 (assuming the unused parts of the program are filled with zeros)

Instruction 0x1... jumps to the address stored in the lower 1.5 bytes, which is 0x200, the start of program memory.

Swift, 11 bytes

while 0<1{}

Works both compiled and as a shell script.

Momema, 4 bytes

j0j1

Try it online!

Explanation

j  0  #  label j0: jump past label j0 (no-op)
j  1  #  label j1: jump past label j0 (re-execute this instruction)

Forked, 0 bytes

Same as the top two answers. Try it online!

Aceto, 1 byte

~~O jumps back to the origin, which conveniently is where the O is!~~

~~Try it online!~~

I didn't see @L3viathan's post so...

Some multi-byte solutions

@1$
1§uu
1§##
```
3§ _
| |
_
```

Try It Online!

Acc!!, 21 bytes

Count i while i+1 {
}

Try it online!

In Acc!!, looping is costly. Whitespace between brackets is required and the statement is a bit wordy. This is pretty self-explanatory, but just in case, it increments i until i - (i + 1) = 0, which is never.

Piet, 2 codels

Can be interpreted and executed using, for example, PietDev, by either

setting the canvas' width to 2, height to 1 and coloring the codels yourself or
clicking on "Open", setting the codel width to 25 and uploading the above image.

Click the step button repeatedly to see the program rotate and loop ~~or the run button to freeze the page~~.

Edit: Try It Online

Edit 2: Just saw that someone already beat me to it.

SNOBOL4 (CSNOBOL4), 10 bytes

L	:(L)
END

Try it online!

Line L is just a goto L, which works perfectly.

Retina, 3 bytes

+`0

If given a single file, Retina uses a Count stage, replacing the input with the number of matches found for the given regex. Here, the regex is 0. Now + loops the stage for as long as the result changes from the previous iteration. So what exactly is happening?

0 is matched against the empty input, giving zero matches, so the result is 0. This is different from the input, so we run this again.
0 is matched against the previous output 0, which now gives one match... so the result is 1.
0 is matched against the previous output 1, which fails... so the result is 0.
... you get the idea.

The result of the loop iteration alternates between 0 and 1, which a) ensures that the loop never terminates and b) ensures that we're not running out of memory because the string doesn't grow.

By default, Retina only outputs once the program terminates, so this doesn't print anything (you can change this behaviour by adding a > after the +, which will then print the alternating zeroes and ones).

As of 1.0, Retina actually also has more traditional while-loops, which you could use with a simpler stage (which doesn't change the string all the time), but they actually require more bytes. One option would be:

//+`

Pyt, 3 bytes

1`ł

Explanation:

1             Pushes 1 onto the stack
 `ł           Loops while the top of the stack is not zero

Try it online!

Aceto, 1 byte

O jumps to the origin of the script. Alternative solutions: Any of v^<>NSEW;§j@

Whispers, 16 bytes

> 1
>> While 1 1

Try it online!

Husk, 2 bytes

ƒI

Try it online!

Explanation

This is the Haskell equivalent of the following

fix :: (a -> a) -> a
fix f = f $ fix f

fix id

where ƒ is fix and I the identity function (id).

REXX, 10 bytes

s:signal s

Of course, the canonical way is a whopping 14 bytes:

do forever
end

Or, depending on implementation:

do forever
nop
end

Implicit, 1 byte

Creates a jump point. When the interpreter hits EOF and there is an open jump point, it loops forever.

Z80, 2 bytes [non competitive, late entry]

18 FE

Assembly

JR -2

LOOP JR LOOP

Note: JR is a relative jump (hex code 18), followed by a signed 8-bit number. It changes the program counter by that number; that happens after the whole command (2 bytes) has been red and program counter increased to point at the instruction immediately after. JR 0 would then just have no effect (a 2 byte version of NOP).

Java (OpenJDK 8), 50 bytes

interface J{static void main(String[]a){for(;;);}}

Try it online!

Since Java 8 interfaces can have method bodies. As they are always public, we save 3 bytes.

Batch, 9 bytes.

a:
goto a

JavaScript, 9 bytes

while(1);

Infinite while loop using 1 as a true value

Operation Flashpoint scripting language, 4 bytes

@0>1

@ waits until the condition (0>1) is true, which obviously never happens, so it keeps looping and checking the condition forever.

Alternative solution (10 bytes):

#l
goto"l"

This usually freezes the game.

Brain-Flak, 8 bytes

(()){()}

Explanation: 

(())   - Puts one on the top of the stack
{  }   - Runs until the top of the stack is zero
 ()    - Filler so that the above function runs

Try it online!

Ruby w/J-uby, 5 bytes

:~!~0

J-uby is all about making procs (i.e., anonymous functions/lambdas) work more concisely in Ruby. It allows symbols to be called like procs without a call to to_proc. Additionally, it adds a lot of functionality to procs. The added functionality we are using here is !~, or "iterate until constant". Basically, it takes a proc and an initial argument, and applies that proc to the argument until the application stops changing the argument (f.(x) == x). So we are calling ~ (bitwise negation) on 0 until they are equal. But due to the nature of bitwise negation (~x != x, ~~x == x for all x), this never occurs. Infinite loop.

7 bytes:

~:^^~:^

A more "readable" form would be (~:^) ^ (~:^). In J-uby, :^ is the call function; f^x == f[x]. The ~ operation turns a two-argument function into a one-argument function which applies the given argument to both sides. So (~:^)^x == x^x. Finally, we apply this to both sides by turning these into lambdas and we get: ->(x){ x ^ x } ^ ->(x){ x ^ x }. This is analogous to (x => x(x))(x => x(x)) in JavaScript, (\x->x x)(\x->x x) in Haskell, or (λx.xx)(λx.xx) in Lambda Calculus.

Java, 23 bytes

enum L{L;L(){for(;;);}}

Works with Java 5 and 6. Not with later versions, not with earlier versions. Just another variation of my "Hello, World!" answer.

Proof of correctness

$ java -version
java version "1.6.0_45"
Java(TM) SE Runtime Environment (build 1.6.0_45-b06)
Java HotSpot(TM) 64-Bit Server VM (build 20.45-b01, mixed mode)
$ cat L.java
enum L{L;L(){for(;;);}}
$ javac L.java
$ java L

Then it hangs.

Vitsy, 1 Byte

~~Since Vitsy loops around the line, a single space is an infinite loop.~~ This functionality was removed in the latest version, but this applies as a special condition for looping around a line.

You could technically also do it like this:

But it throws an error after a little while:

Exception in thread "main" java.lang.StackOverflowError
    at com.VTC.vitsy.OperativeHandler.doOperation(OperativeHandler.java:6)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:88)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    at com.VTC.vitsy.Vitsy.loopHandler(Vitsy.java:82)
    at com.VTC.vitsy.Vitsy.opHandle(Vitsy.java:195)
    ... (few hundred more lines)

It's a pretty staggeringly long error.

The 'correct' way to do an infinite loop in Vitsy, however, is this:

[1]

where 1 is any number [1-f]. [ starts a while loop, 1 pushes 1 to the stack, and ] pops the top item off the stack and tests if it is 0. If it isn't, go back to the beginning of the loop.

Smalltalk-80, 8 bytes

(or more)

First there is no such thing as a program in Smalltalk-80, just write a snippet anywhere in a text pane and press the doIt! pop up menu. But we can eventually write snippets that don't stop.

[]repeat

is the obvious infinite loop

thisContext restart

is our kind of goto solution

|x|
x:=[:b|b value: b].
x value:x

is a block closure evaluating itself recursively, but since a closure close over local variables, we can do it shorter:

|b|(b:=[b value])value

Since Smalltalk-80 don't do recursive tail elimination, this infinite loop will starve memory and won't really be infinite.

We also may retry code that raised an exception, if ever the exception was temporary...
(a costly variant of repeat)

[0halt]on:Halt do:[:e|e retry]

We can also play with recursive structures, modulo recursive tail elimination problems:

|x|(x:=1->0)key:x;hash

We can also exploit weaknesses of the interpreter itself - this is in latest Squeak 6.x (you'll have to kill the image):

|c|c:=Class new.c superclass:c.c new

Since new will invoke self basicNew initialize, the interpreter will loop in #initialize method lookup. This time no memory growth, the loop is solid.

There must be some shorter exploit, but I'll stop here, Smalltalk is more talk than small for golfing...

In a certain sense, the interpreter performs an infinite loop itself, so doing nothing is already doing an infinite loop, but that's cheating.
In the case of Smalltalk though, since we save the state of the interpreter in an image, and later resume an image at each restart, we're just running the infinite loop for more than 20 years now (or one of its avatars). Since it's ran over a virtual machine, it even perpetuates across different machines, OS, architectures, so it's a quite robust loop!

Hodor, 22 bytes

hodor............(1){}

Hodor!

Or, (44 bytes)

hodor............(hodor. rhodor!? hodor? ){}

4, 12 bytes

3.6147281494

Try it online! (Note: The interpreter used by TiO raises an error with this code. This is caused by the interpreter, not the program itself)

Explanation (According to the wiki specifications):

3.         Start program
6 14 72    Set memory cell 14 to 72
8 14       While cell 14 != 0
9          End while
4          End program

jq 1.5, 13 bytes

until(null;1)

this also works but is no shorter:

repeat(empty)

Nhohnhehr, 11 bytes

+-+
|$|
+-+

Try it online!

Thotpatrol, 78 bytes

📡JACKING IN📡
🤷 👐 a.txt
🇺🇸REPORT UNPATRIOTIC ACTIVITY🇺🇸

A simple self recursive program that points the interpreter to call itself recursively. The assumption is that the program is in a file called "a.txt" The call is embedded in a try statement to suppress stack overflow warning. The structure is as follows:

function a:
    try a

Link to implementation: https://github.com/MindyGalveston/thotpatrol-

Motorola MC14500B Machine Code, 0.5 0 bytes

Explanation

According to the manual, the system is configured to have a looping control structure. The program counter counts up to its highest value, wraps back around to zero, and counts up again.

Cubically, 2 1 byte

This should not work, but it does due to how the interpreter handles the number of loops. With no jump points, ) jumps to the beginning of the file, which is )... cue infinite loop.

This is the proper version that will work if I fix the interpreter:

()

( can be jumped to if all provided arguments are truthy (none are provided so they all are). ) can jump back to the most recent ( if all provided arguments are truthy. Once again, none provided so it jumps regardless.

Emojicode, 28 bytes

🏁🍇🔁👍🍇🍉🍉

Newline, 3 bytes

i[]

Same as brainfuck answer. Adds one and loops

[i]

also works

{}

works only if loops[0]=infinity

Lean Mean Bean Machine, 3 bytes

O
~

Marble spawns at O, drops to ~, which teleports it back up to the top of the column.

Unreadable, 25 bytes

'"""""'"""'""""""'"""'"""

Try it online!

Explanation

'"""""                       While X is true, do Y
      '"""                   [X] - Return 1
          '""""""            [Y] - Set variable X to value Y
                 '"""           [X] - Return 1
                     '"""       [Y] - Return 1

XSLT, 173 bytes

<xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0"><xsl:template name="a" match="/"><xsl:call-template name="a"/></xsl:template></xsl:stylesheet>

Requires a trivial XML file as input (<root /> will suffice), since XSLT won't actually do anything unless given input. You can test it here. It's possible to remove some of the spaces or the xmlns:xsl attribute and still have it parse, but most XSLT lint programs will reject the shorter versions, so this is the shortest "correct" XSLT script I could come up with that loops forever.

MOO, 30 28 26 bytes

while(!suspend(0))endwhile

The suspend(0) is necessary to avoid "task ran out of ticks'

Triangular, 3 bytes

\/<

Triangular is my first attempt at a two-dimensional esoteric language. Code is formatted into the smallest possible triangle - in this case, a triangle of size two. The IP starts moving Southeast from the top of the triangle.

The above code arranges into this triangle:

 \
/ <

Commands:

\ direct IP Southeast (towards the <)
< direct IP West (towards the /)
/ direct IP Northeast (towards the \)

INTERCAL, 42 18 bytes

(1)DO COME FROM(1)

Idea taken from @flawr's comment.

EDIT: Holy crap, INTERCAL is actually shorter than C#. I don't know if that's ever happened before...

42-byte version

DO(1)NEXT
(1)DO FORGET #1
PLEASE DO(1)NEXT

Fission 2, 1 byte

Try it online!

Spawns an atom moving right, wraps on the end of the line, R simply sets the atom's direction to right after the program has started

Decimal, 6 bytes

91D91D

Pretty simple:

91D   ; declare jump 1
91D   ; goto jump 1

Try it online! I mean, not exactly try it, but... you know what I mean.

Alice, 0 bytes

Try it online!

The empty program in Alice does nothing... in particular it doesn't terminate.

Lua and RBX.Lua, 14 bytes

while 1 do end

Pretty self explanatory. While 1 is true, it will iterate through the loop.

Samau, 3 bytes

`xx

Explanation

`x      push the quoted function [x]
  x     execute it without popping it

It works like the Mathematica program #0[]&[], but Samau doesn't have an iteration limit.

QBIC, 2 bytes

{}

This compiles into QBasic as DO: LOOP.

Note that not long after answering this challenge, the workings of QBIC has been altered. We now see IF, DO and FOR as 'language constructs': an opening statement, <code goes here> and a closing statement. Note that WHILE/WEND, functions and subs could also be supported as language constructs in the future.

Those currently supported by QBIC (IF, FOR and DO) are opened using ~, [ and { respectively. Closing them can be done with either a ] or a }: these mean 'Close the last language construct' and 'Close all constructs'.

QBIC has had the ability to auto-close language constructs for some time now. The above code could be one byte only: {. The final statement that QBIC adds to its own source is a } to close all constructs.

OIL, 1 byte

TIO does not currently support OIL.

Explanation:

6 // Jump to cell A.
0 // Implicit 0.

Forte, 4 bytes

1REM

Without an END statement, Forte programs loop infinitely. The empty program is an error, so we leave a comment.

Try it online!

BitCycle, 3 bytes

>1<

Places a 1 bit on the playfield and infinitely moves it back and forth between the > < devices.

SmileBASIC, 5 bytes

EXEC.

. is the same as 0.0, so it runs EXEC 0, which executes the program stored in slot 0, which is the default slot.

Example use:

PRINT TIME$
WAIT 1
EXEC.

Chip, 5 bytes

*S

+3 for -w on the command line, which allows the program to run without reading from stdin. Instead, it uses an internal source (generating 0x00 repeatedly by default).

* is a constant high signal; this turns on adjacent elements.
S when powered, suppresses output for the current cycle.

PKod - 1 byte

Version 1.1 was released very recently as I still update this, which implements this new function/command

<
Explanation: Jumps back to first byte in code. So it jumps back to itself. Normally meant to be used with test cases (e.g.: if prime, jump back to start - iterate all code again, but since thread asks for infinite loop, why not)

Alternative version, 4 bytes:

-+ia
Explanation: -+ , remove then add 1 to value. Thus value keeps jumping from 0 and 1. "i" jumps two blocks back in code until value is next char after "i". Thus until char is 1. Thus until value reaches ascii code of a which is 97. Which never happens

Pari/GP , 9 Bytes

while(1,)

(dummy text such that SE accepts the answer)

tcl, 7 bytes

vwait v

Explanation

DUP, 6 bytes

DUP is a dialect of Wouter van Oortmerssen’s FALSE, invented by Ian Osgood.

[1][]#

Explanation:

This uses DUP’s while loop. the first block [1] is the condition block that checks if the condition is true/nonzero, and if it is, executes the second empty block [] that does nothing. The execution block is executed as long as the condition is nonzero.

 [1][]#
 instr.    data stack   return stack
 [        0                         push '[' location
    [     0,3                       push '[' location
      #   0            5,0,3        push '#' and '[' locations on return stack
 [                     
  1       1            5,0,3        push 1 (truthy)
   ][]    0            5,0,3,0      condition true → execute 2nd (empty) block
 [                                  jump to condition block (location 0, popped from the return stack)
  1       1            5,0,3
   ][]    0  ...       5,0,3,0             infinite loop

Just for the fun of it, here is a visually equally long solution that is 8 utf-8 bytes long, but unique to DUP because FALSE lacks this functionality:

[A]⇒AA

Explanation:

         data     return
         stack    stack    operator
[          0                                 push location of open bracket
   ⇒                                         operator assignment to
    A                      A => 0            new operator A (at address 0)
     A                                       execute operator A, push current IP location on return stack
[                 5                          move to operator A at location 0
 A                5,1                        execute operator A, push current IP location on return stack
[                                            move to operator A at location 0
 A                5,1,1                      execute operator A, push current IP location on return stack
...
[
 A                5,1,1,1,1,1,1,1...

As you can see, the latter recursive solution quickly fills the return stack and sooner or later leads to a stack overflow, depending on the available RAM.

A full introduction and explanation of DUP instructions etc. can be found on my GitHub repository or on the pages linked on the online Javascript DUP interpreter webpage.

P.S.: I just noticed that someone already posted a FALSE version. I’m sorry for the duplicate. In this case both languages look the same.

GNU Sed, 3 bytes

Unlike this answer by @Digital Trauma (which relies on bug #21250: sed: empty label for :/b/t commands), does only use documented Sed commands, in the same byte count.

Golfed

G 
D

Explained

G       #Append a newline to the contents of the pattern 
        #space, and then append the contents of the hold
        #space to that of the pattern space.

D       #Delete text in the pattern space up to the 
        #first newline, and restart cycle with the 
        #resultant pattern space, without reading a new 
        #line of input.

APL, 2 bytes

→1 go to line 1 (this line)

7, 3 bits, represented as 1 byte on disk (language postdates challenge)

Try it online!

This is fairly simple. The program starts by pushing 7 onto the stack (which is what 1 does); then when the end of the program is reached, the top nonempty stack element is executed, without removing it from the stack (although any empty elements above it are removed). 7 just pushes an empty stack element to the stack, which immediately gets removed as it's the end of the program, and so nothing has changed and the same stack element just gets run again, repeatedly.

Excel VBA, 7 Bytes

Do:Loop

Note: the above freezes Excel - the shortest Excel VBA loop that does not do this is Do:DoEvents:Loop (16 Bytes)

uBASIC, 7 bytes

1GOTO1

Note trailing newline. Trivial BASIC variant.

Try it online!

Scala 12 bytes

while(true)0

Avoid one character using 0 instead of while(true){}

tinylisp, 13 bytes

((v(d f(q(L(f

Parenthesis autocompletion really helps!

We define a function f that calls itself using tail-call recursion. Functions in tinylisp are lists containing two elements: parameter list and expression. Here, our parameter list is L (which makes this a variadic function: L is bound to a list of all arguments) and our expression is (f) (calling the function with no arguments).

((v(d f(q(L(f))))))
         (L(f))      The function list
       (q      )     Quoted to prevent evaluation
   (d f         )    Define f to be that list
 (v              )   The d call returns the name f; evaluate it to get the function itself
(                 )  Call the function

Use Ctrl-C to halt execution.

Lithp, 27 bytes

 ((def x #::((next x)))(x))

Define a function, x, which uses tail recursion (via next) to call itself. Then call function x.

This program will never finish. You can't even CTRL+C out of it since keyboard input isn't handled in Node.js whilst in a while loop.

If one were to provide the -d flag to run.js, they would see the function calling itself over and over, never finishing nor running out of stack space.

This was a neat feature to get working in my language. Typically one would use some sort of logic flow to determine whether to return a value or tail recurse back into the current function (using next or recurse.)

The implementation of such tail recursion was fairly simple, but its implications in my functional language are great. My feature set is getting nearer and nearer to Erlang's every week. And that's fun.

FALSE, 6 bytes

[1][]#

This is a while loop (#) with an empty body function ([]) and a condition function that always yields a truthy value. It runs forever without yielding output.

Interpreter used.

Pushy, 2 1 bytes

Try it online!

Hah, [ is just an infinite loop, that's its only function if you see here.

Casio FX-7000G, 5 bytes

Lbl 0
Goto 0

Quite self-explanatory: Goto 0 indefinitely jumps back to the beginning of the program. The calculator stores each token as a byte, so Lbl and Goto are 1 byte each.

Cubix, 0 bytes

Alternatively, any single character does exactly the same.

Test it online!

Cubix is a stack-based 2D language, created by me in March 2016. Cubix differs from ordinary 2D languages in that it's not strictly 2D: the code is wrapped around a cube. Any one-byte program wraps to this cube net:

   ?
>. . . .
   .

where ? represents the character, and the IP (instruction pointer) starts at the arrow. . is simply a no-op, and when the IP reaches the right side of the cube net, it simply wraps back around to the left. Thus, any 1-byte program does nothing forever, no matter what the character is (as long as it's not whitespace).

Thanks to @ErikGolferエリックゴルファー for reminding me that the empty program does the same. When Cubix was originally created, this didn't work, because the interpreter created a cube of size 0 and threw an error when it tried to run. This was fixed a while ago, and it is now impossible to cause an error in Cubix.

TI-83 Hex Assembly, 3 bytes

PROGRAM:L
:AsmPrgm
:C3959D

Run it with Asm(prgmL). Jumps to itself over and over. The only way to stop the program is to physically remove the batteries from the calculator. I count each pair of hex digits as one byte.

Microscript, 2 bytes

1{

Essentially just n=1;while(n!=0){}. The interpreter autocloses any loops, etc. that are left open.

The Microscript II program 1[ is equivalent.

Clojure, 21 10 bytes

(#(recur))

After posting a question of meta regarding what's considered a full program in Clojure, it seems that the above is acceptable. If you paste it in an empty source file, it will run.

Commodore Basic, 3 bytes

1R╭

PETSCII substitution: ╭ = SHIFT+U, ungolfs to 1 RUN.

Taking advantage of Commodore Basic's shortcut forms and the fact that any immediate-mode command can also be used in a program, this code simply runs itself, forever.

Alternatively, a more thoroughly infinite loop is the immediate-mode command

S|7

(PETSCII: | = SHIFT+Y, ungolfs to SYS 7).

This transfers execution to memory location 0x0007. The BASIC interpreter stores the current search character here; when running the above code, this character is the double-quotation mark with byte value 0x22. Opcode 0x22 is an undocumented HALT opcode, which works by putting the 6510's micro-operation interpreter into an infinite loop. The only way out of this loop is to reset the computer.

PHP, 9 bytes

back to basic:

L:goto L;

^_^

Lithp, 40 bytes

((platform ext)(invoke (stdin) resume))

There are presently no loop constructs in my language. Instead, we tell NodeJS (in which Lithp is implemented) to resume the process.stdin stream. We haven't setup a handler, but the process will never exit.

In fact, you have to send a kill message to abort the application.

Unary, 695 bytes

695 zeros. Program that prints the actual code can be found here.

D2, 3 bytes

+[]

Same as Brainfuck

More interesting version using the preprocessor (the code is actually never executed because the infinite loop is in the preprocessor):

(@a)a@a

Simple recursive macro

Bash, 10 2 bytes

$0

Runs the file specified by $0 (i.e. itself). Requires that the script is executable.

05AB1E, 2 bytes

[[

Try it online!

Explanation:

[     # Infinite loop start
 [    # Infinite loop start
      # Implicit infinite loop end
      # Implicit infinite loop end

You need something inside the infinite loop, or else it will just end

Emotinomicon, (2 chars) 6 bytes

ℹ⏩

I cleverly chose the ℹ character for 3 bytes instead of 4. Explanation:

ℹ⏩ explanation
ℹ  push the imaginary unit to the stack
 ⏩ close loop

It works, because 1) ⏩ has got a value (i) 2) ⏩ can't find a ⏪.

To test the code, do the following:

Open the interpreter.
Clean the box and then put a 😷 in it (not part of the code, just in case you have a dirty output stream).
Paste the code after that one-big-toothed strange guy.
Click on "generate explanation". Watch the steps done there (also, no mono-spacing issues).
Click on "submit". Warning: the code will run after this step!

Visity, 0 bytes

(no code)

As this answer points out Visity wraps around producing an infinite loop.
Or more conventional (2 bytes):

[]

CMD, 2 bytes

Must be in a file named a.bat or a.cmd

@a

Must be in a bat or cmd file

@%0

dotsplit, 4 bytes

jump

jump: pops number from stack, moves back that many commands

When the stack is empty, popping results in zero. Hence, it will jump on to the jump command.

In keeping with design principles, the problems this has will not be addressed, but perhaps a new command will be added, called loop-safe or something

Sinclair ZX-81 Basic, 6 bytes

1 RUN

This would take 6 bytes in RAM (2 bytes for the line number, 2 bytes for the line length, 1 byte for the RUN token and 1 byte for a newline).

The way it works is (essentially) the same as the 10 GOTO 10, the first line in the program causes the program to be executed.

Racket 18 bytes

(λ()(let g()(g)))

Lolo, 20 bytes

lOLolo loLOlo loloLO

You can also put in l at the end, but it won't ever get called.

ABCR, 2 bytes

5x

Explanation: 5 loops while the front member of queue B resolves to a truthy value. The default value for queue B is 1, so the loop continues until it finds its matching x; since there are no operations in the loop, it continues ad infinitum with no output.

LI, 2 bytes

R0

Usually, LI programs (under the current interpreter) always take in input. No input is commonly represented as falsy input, i.e. 0; however, in order to truly accept "no" input, I need to provide my own input to the Recurse function.

Explanation:

R   Recurse with input:
 0  Literal 0

LI, 1 byte

If we're a bit more lax with the input requirements, simply R will work. It doesn't error if you don't give it an input, but that's simply because, while it interprets the input as invalid (empty), it doesn't try to use its value.

Bash or perl, 6 bytes

exec$0

I realize that are both bash solutions and perl solutions this length or shorter, but there are no dual-language solutions. Yup, it runs with either language.

J, 7 Bytes

(-^:_)_

A more "readable" form would be (- ^: _) 1. The _ can be any non-zero number and it will work the same (_ represents infinity in J). ^: is the "power" conjunction; it iterates a verb a specified number of times. E.g. (f ^: 3) 0 == f(f(f(0))). When told to iterate _ times, it keeps applying until it produces a constant output. Since negation never reaches a limit, this is an infinite loop.

PHP, 8 26 bytes

set_time_limit(0);for(;;);

Almost forgot: default time limit is 30 seconds and script will exit with a Fatal Error if I don´t unset it.

Run with -r

Copy, 10 bytes

copy 0 0 1

Copy the current instruction at the next location.

Basically a Core war imp.

Turtlèd, 3 bytes

any character but * works in the middle

[-]

alt:

{*}

Explanation:

[    ] Brackets make a while loop. The character after the opening bracket is taken, and
       the loop is executed while the current cell is not that character.

hence

[-]

Runs whilst the current cell is not -, but will never change it to that value, so infinitely runs, and never ouputs as it only outputs at the end.

{*}

works similarly, but it runs while the current cell IS that value. by default, the starting cell is *, so it runs forever, since it will never change its value

(nontrivial) Polyglot, Turtlèd and Brainf*** 5 or 4 bytes, depending on implementation

doesn't make use of BF non instruction nops.

If you happen to have another cool esolang that might be able to be fitted in, tell me.

+[-+]

In wrapping implementations,

in non-wrapping:

+[+]

Explanation:

+    - essentially a nop in Turtlèd with no string, increments cell in BF
 [+] - loops while current cell is not: {BF:0, Turtlèd:"+"}. increments cell in BF

 [+-] - loops while current cell is not {BF:0, Turtlèd:"+"}. - is nop in Turtlèd with 
        no string, and `+-` together is nop (+1,-1) in BF

S.I.L.O.S, 9 bytes

:a
GOTO a

Try it online!

Binary Lambda Calculus, 3 bytes

Before I dive into the explanation, let's start with the program itself.

F†€

Trust me, it's pure luck that they're all printable, and I'll get to why it is 2 1/4 bytes instead of 3 after the explanation. I'll explain this by walking through the process I took to create this program.

To start, BLC programs are just lambda calculus programs encoded in a special way. With this in mind, let's begin with the lambda calculus program that enters an infinite loop, known as omega.

(λx.xx)(λx.xx)

This results in an infinite loop because, according to Wikipedia, it reduces to itself after a single beta-reduction. To convert this into BLC, we must first convert it to De Bruijn indices. It converts into the following:

.λ.11λ.11 (The dots after the λs are necessary for BLC but not part of De Bruijn indices)

Okay, now that it's in De Bruijin indices we can now convert it into BLC where λ translates to 00, function application or . translates to 01, and numbers are represented as 1^n0 where n is the number. Knowing this, it translates into the following binary:

01 00 01 10 10 00 01 10 10

This is why it's 2 1/4 bytes. As BLC instructions aren't full bytes (with the exception of 7), it is rare for programs to fit exactly into a certain byte count. To turn this into hex, we have to pad it in order to make it fit into 3 bytes. Doing this yields the following:

46 86 80

There we have the hex dump of our program! It runs in an infinite loop, doesn't run out of memory to my knowledge, doesn't output anything, and is a complete program that can be saved and run by piping the contents of the file to the official interpreter. You can also pipe the binary text to the interpreter and add the -b flag, to demonstrate that the non-padded version can be run.

Element, 3 bytes

!{}

The control stack is initially empty, the ! negates it to truthy, and {} is a loop-while-true which never ends.

Ru, 4 bytes

¿Ϟ{}

¿ call a function while koppa is not 0/nil/false. But since Ϟ also return its argument, it's possible to chain ¿ and Ϟ.

Logicode, 24 bytes

circ r(a)->r(a)
out r(1)

Logicode is a new language that I made recently. It only consists of the basic logic gates AND, OR and NOT.

It also contains some nifty stuff like conditionals, make-your-own circuits, and output.

Basically, the first line declares a new circuit, r, with an argument a, and declares the output of the circuit to be r(a). This basically results in an infinite loop.

out r(1) outputs r(1).

Java, 50 bytes

interface D{static void main(String[]a){for(;;);}}

S.I.L.O.S, 11 bytes

lbla
GOTO a

T-SQL, 8 bytes

l:goto l

(Not to be confused with this excellent answer from @MickyT in Standard SQL)

Nim, 16 bytes

while on:discard

on is an alias for true. Nim disallows expressions that aren't explicitly discarded, so we just discard nothing.

Gaot++, 27 bytes

bleeeet bleeeeeet bleeeeeet

bleeeet enters the loop, and bleeeeeet bleeeeeet switches IP direction repeatedly.

Sesos, 2 bytes

0000000: 080a                                              ..

Try it online! Check Debug to see the generated binary code.

How it works

The binary file above has been generated by assembling the following SASM code.

nop       ; Set an entry marker.
    add 1 ; Increment the current cell.
          ; (implicit jnz)
          ;     If the integer in the current cell is non-zero,
          ;     jump to the previous instruction.

AlphaBeta, 2 bytes

is a no-op, and N moves the IP to the value stored in the position register (initially 0) if the third register is 0 (which it is).

Benul, 0 bytes

In Benul, programs are placed in an implicit infinite loop and require special conditions to terminate.

MarioLANG(4 Bytes)

><
==

Trigger, 5 bytes

 !  !

Generally, any program with an "ABAAB" pattern should work. toggles the ' ' trigger to 1, ! toggles the '!' trigger, and ! jumps to the nearest ! if the ' ' trigger is 1 (which it is).

Enigma-2D, 2 bytes

RL

The IP alternates between moving rightwards and leftwards.

Brachylog, 2 bytes

=\

Takes no input and no output.

Explanation

= will label the input with an integer. \ is always false and will therefore trigger backtracking. Since the input has no constraints, it will unify as following, through backtracking: 0, then 1, then -1, then 2, etc. This will go on forever.

0815, 7 bytes

}: :#:

(trailing space)

}:0:#:0

Explained:

}:0:    :Create a label 0
    #:0 :Go to the label 0 if Z is 0h

Linux shebang, 5 bytes

#!./a

Must be named as a.

Will run out of memory, but this is an infinite loop.

BASIC, 8 bytes

1 GOTO 1

Goto self

niblet, 2 bytes

The space is just a no-op, and the [ moves the IP to the previous character.

BSM, 1 byte

A single space character. Had to use some brute-forcing for this... After about 125 cycles, it loops between the states 55, EF, B1, 5A, AD, B2, D9, DC, 9C, 13, 19, and F9.

Subskin, 6 bytes

A series of six newlines. It contains two instructions, both of which set the IP to the second instruction.

Barely, 0 bytes

That's right! If the Barely interpreter receives the empty program, then it just hangs. Normally, the code would be terminated with a ~ to separate it from input, so the interpreter keeps reading EOF and never runs anything. Tested on DOSBox v0.74 using input redirection.

Churro, 20 bytes

{o}=}{==={*}{===={*}

Consists of three churros. {o}=} pushes 1 to the stack, and {==={*} and {===={*} loop while the top of stack is not zero.

Noobinary, 4 bytes

0000 is a single instruction that jumps to the last 00 (or start of program) if the top of stack is 0.

Glypho, 3 bytes

1[]

Pushes 1 to the stack, then loops while the top of the stack isn't 0. Uses the Java interpreter. This is shorthand for the following "real" Glypho program:

  !" ! " !"!

Ceylon, 30 29 bytes

This is an eternal loop (which also will not run out of memory or stack or something), 30 bytes:

shared void l(){while(true){}}

This can be golfed down one more byte to 29:

shared void l(){while(1<2){}}

In the Ceylon web runner you have to remove the function wrapper, getting this 12 byte snipped:

while(1<2){}

(I had to kill my Chromium window when trying this.)

This eternal recursion will quickly run out of stack space (about 1024 calls on my JVM implementation, with a StackOverflowError), 22 bytes:

shared void r() {r();}

I wouldn't consider this a valid solution.

Note that the for-loop (which is the shortest endless loop in Java) in Ceylon can only loop over an iterable, and all ways of constructing an infinite iterable are longer. Here is one example (38 bytes):

shared void f(){for(x in{1}.cycled){}}

Subleq bytecode, 3 binary words

00 00 00

Equivalent to

*00 = *00 - *00
if(*00 <= 0) goto 00

Tellurium, 5 bytes

[i|p]

This is pretty simple to explain. It runs the command p (Does nothing, which is why it's good for this challenge) forever (i = infinity).

Pyke, 1 byte

Try it here!

The r node sets the counter to 0, resetting the program.

Seed, 3 bytes

0 0

Equivalent to an empty Befunge program.

Dumbfuck, 2 bytes

.?

. sets the current cell to 1, and ? jumps to itself (due to the cell being an odd number).

Grocery List, 6 bytes


W
L
E

Note the preceding newline. W pushes 100 to the stack, and L and E loop while the top of stack isn't 0.

ACIDIC, 1 byte

A single newline character. In the C# interpreter, the empty program (i.e., the second line) just loops forever.

Sonic Pi

loop do end

I think that's easy to understand.

GPRX 3000, 1 byte

Sets the IP to the value of register A (which is initially 0).

XRF, 5 bytes

FFFFF

Only contains one chunk, which is a NOP. The instruction pointer is the top of the stack, so it never changes and just repeats the code infinitely.

Revaver2pi, 5 bytes

TEL 0

TEL searches (cyclically) for the next TEL with the same first argument and jumps to there.

MATL, 3 2 bytes

Quite simple really:

`T

`    # Do ... while
 T   # True
     # Implicit end, normally: ]

Try it online here (Please stop it after testing, don't keep it running).

PRINDEAL, 10 bytes

a t
 t
 t
 t
t

Creates a command named t that calls itself, then calls itself regardless of whether the first call suceeded. An interpreter was posted which does not use recursion, and thus will keep running forever (or until it runs out of memory)

evil, 2 bytes

mb

Nothing to see here, just another self-GOTO...

Braille, 6 bytes

⠁⡀

Self-GOTO with a NOP. If it isn't displayed properly (and/or you want to test it):

0000000: e2a0 81e2 a180                           ......

tinyBF, 5 bytes

+|= |

Similar to +[] in BF. The space is required here, as |=| (meaning []) is converted to ,.

Codan, 4 bytes

«»

All loops in Codan are infinite if they don't have breaks. This program is transpiled to C as follows:

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <termios.h>
int main(void)
{
    int mem[10000];
    int alpha, beta, t;
for (;;) {
}

    return 0;
}

Pancake Stack, 71 bytes

Put this # pancake on top!
[a]
If the pancake is tasty, go over to "a".

Yay, self-GOTOs with #pancakes...

V, 1 byte

ò

V is a 2D string based golfing language that I ~~wrote~~ am in the process of writing, inspired by vim. In vim, recursive macros are a little bit of a pain to set up, so I tried to make them as easy as possible in V. The syntax for a recursive macro is:

ò<code>ò

This is equivalent to

qq<code>@qq@q

in vim.

V will automagically fill in the missing delimiter (in this case, the second ò) so we can leave it off, giving us a nice and simple one-byte solution.

Gammaplex, 0 bytes

In Gammaplex, it isn't possible to write a program that isn't an infinite loop. So I just write a program that doesn't use input/output.

Parallax Assembly, 0 bytes

The effect if set up correctly leaves the processor core initialized to zeros, which happens to be a nop. Running off the end executes the processor special registers, which also happen to be initialzed to zero except for ina, but the high bits are zero (for some reason this particular CPU floats low rather than high) so it's still a nop, and loops back to the beginning by overflowing the IP register.

Incidentally a blank CPU is already set up correctly so it's just a matter of loading the null program without disturbing the state.

JavaScript, 8 bytes

for(;;);

Since the expression to evaluate is omitted, it will always evaluate to true (i.e. your classic while(true){} loop in "disguise").

Fuzzy Octo Guacamole, 2 bytes

()

A empty infinite loop.

C64 Machine Code, 2 Bytes

D0 FE

Branches to itself if the zero flag is not set.

Branches are single-byte offsets from the next instruction location, and 254 is -2 in two's complement... the BNE instruction (D0) takes one byte of memory, and the offset takes a second byte, so branching two bytes back branches back to itself. The zero flag is always cleared when code is loaded into memory.

Note that this is not a recursive subroutine call, so you will never run out of memory. Also note that there is no header, compiler, or executable overhead... it is truly a two-byte program :)

Sh, 17 bytes

while :;do :;done

Probably the shortest one.
Ungolfed:

while [ : ]; do
:
done

: is a command that always returns 0 (a.k.a. the same as true).

Sh+coreutils, 13 bytes

yes>/dev/null

yes is a program from the coreutils package, that, when not given an argument, continuously outputs y (note the newline), while given an argument, outputs that argument plus a newline continuously. --help and --version display usage and version number, respectively.

Jumper, 2 bytes

:0

Move along, nothing to see here but a simple self-GOTO...

The Infamous Shakespeare Programming Language, 122 bytes

.
Page,a cat.
Ford,.
Act I:
Scene I:z
[Enter Page and Ford]
Page:
Am I better than zero?
Ford:
If so, let us proceed to z.

Pylongolf2, 2 bytes

><

That's it.

Cy, 8 bytes 6 bytes

{1} do

Explanation:

{1} is a block (procedure) that pushes 1 to the stack (truthy). do will continue to execute that block until it pushes something falsy to the stack, which will never happen.

Bash, 10 bytes

f(){ f;};f
It does end up crashing the program /bin/bash, but I think that's allowed.

MNNBFSL, 4 bytes

[[<]

A bit complicated. Read the Esolangs page for more information.

Jelly, 1 byte

ß

Recursively calls the main link. Thanks to tail call optimization, this results in an actual infinite loop.

Try it online!

Come Here, 11 bytes

1COME FROM1

WhoScript, 4 bytes

1v;d

The 1 tells the interpreter to use one-line mode, v starts an infinite loop, and d loops back to the v.

Python 3, 100 79 bytes

x=lambda x:x(x)
while x:
    try:x(x)
    except BaseException:pass

Note: this doesn't freeze my IDLE or my machine, nor does it hog lots of memory: it just occupies (more than) a core on an eight-core processor.
Also note: pressing CTRL-C (or whatever you have KbInt bound to) a few times will eventually cause it to error and quit. I could write in protection for that but it's pointless in this case.

Mathcad, 4 "bytes"

In Mathcad the user enters programming language commands using keyboard shortcuts (or picking them from the Programming Toolbar) rather than writing them in text. For example, typing ctl-] creates a while-loop operator that has two "placeholders" for entering the condition and a single line of the body, respectively. Typing = at the end of a Mathcad expressions causes Mathcad to evaluate the expression.

So to enter the above while loop, the user enters "ctl-]11=". Mathcad will then eternally evaluate 1.

ForceLang, 9 bytes

Works by abusing the new def instruction.

def a a
a

Original 14-byte answer:

label l
goto l

Factor, 15 bytes

Yea, Factor is verbose.

[ t ] [ ] while

Do nothing forever. Hangs the Listener.

Perl, 6 bytes

{redo}

See redo in perldoc.

Gogh, 1 byte

Another Gogh answer!

Ø

The character Ø infinitely loops all code before it. (from the wiki)

Mathematica, 10 8 bytes

0~Do~∞

Hoon, 4 bytes

|-
$

The |- rune is a synthetic rune that expands to =<($ |.($)), a macro that expands to a self-calling function. That function returns $, the name of a limb. Gates like |. are essentially "objects" in Hoon, called cores, with a list of limbs. $ is the empty name of the limb containing the code to run to call the gate. The code creates a core with one limb, $, that returns the value at the limb $ (itself) and calls it immediately.

Grond, 7 bytes

w(1){}

Compiler here https://github.com/epicTCK/Grond

Milky Way 1.6.5, 3 bytes

&{}

See the docs.

DUP, 2 bytes

~!

Try it here.

Found this completely by accident.

Explanation

If the stack is empty, ~ (normally bitwise NOT) just pushes -1 to the stack. !, which is normally lambda execute, pushes 1! to the return stack, which then tells the IP to go back to ~, and the loop goes on.

Pylons, 4 bytes.

w,1}

Loops while 1 is true.

GNU Make, 16 bytes

f=$(call f)
$(f)

The loop is in make itself, not a program it invokes.

C, 11 bytes (on old x86)

main=65259;

65259 or 0xfeeb is the machine code eb fe or jmp -2. Jumps are relative to the next instruction, so this loops.

This compiles (with a warnings) and works on my Linux 2.4.9.
Newer Linux will usually put main in a non-executable section. Adding const will fix it, but at an unbearable price.

Just noticed kirbyfan64sos's answer that uses the same machine code. But it's not in C.

NTFJ, 2 bytes

Try it here!

~^

This is stiflingly simple. ~ pushes a 0 to the stack, and ^ pops N and goes that position in the source code. The simplest unconditional loop in NTFJ is this.

Carriage, 7 bytes

#11-\@!

Smallest self-copying program that I could find.

Puzzlang, 4 bytes

XX X

I have verified that this is, in fact, the shortest possible solution. Equivalent to +[] in BF.

Magic, 7 bytes

skip -1

A simple self-GOTO.

Condit, 2 bytes

Note the trailing space. Due to what I believe is a bug, the Python 3 interpreter loops infinitely on unrecognized tokens.

RPG fixed, 133 bytes

H dftactgrp(*no) actgrp(*new)
H option(*srcstmt:*nodebugio)
H bnddir('QC2LE')
C     A             TAG
C                   GOTO      A

Basically it defines a few headers for it to compile (h-spec) and have to rows of c-specs. If it was written in free format it would have looked like this:

H dftactgrp(*no) actgrp(*new)
H option(*srcstmt:*nodebugio)
H bnddir('QC2LE')
/free
tag a;
goto a;
/end-free

Or in Perl like this:

a:;     # This is a label
goto a; # Goto that label

Oracle PL/SQL 11.2, 30 bytes

BEGIN LOOP NULL;END LOOP;END;/

Sally, 20 bytes

void a a
void main a

Why the extra four bytes? First, I pipe it to sally2c, which transpiles it to C:

#include "sally.h"

/* {void -> void}: */ void apply_a(void)
{
  apply_a();
}

/* {void -> void}: */ int main(int argc, char ** argv)
{
  if(argc <= 0) { fprintf(stderr, "0 values needed"); exit(1); }
  apply_a();
  {
  }
  argv = argv;
  return 0;
}

Then, during compilation, I use the -O2 flag for tail-recursion (otherwise it segfaults), which I believe is necessary for consideration as a language.

2-ill, 7 bytes

@ @
@$@

The instruction pointer just loops counterclockwise forever.

Postscript, 6 bytes

{}loop

Infinite loop that does nothing. Ties up 1 core at 100% when run under ghostscript. Interestingly, the ghostscript interpreter keeps accepting input, so it must be running a separate thread. Not sure what would happen if this was sent to a printer, though.

Lua, 14 bytes

repeat until a

while 1 do end

The first one works because a is nil (because it is undefined), so it will never be true. The second one works because anything that is not false or nil, when casted to a boolean, evaluates to true.

Not boring version, 23 bytes

debug.getinfo(1).func()

debug.getinfo(1) returns the debug information of the current stack, and the func property represents a function that executes that stack. This will call the main stack an infinite amount of times.

C#, 38 37 36 bytes

class B{static int Main(){for(;;);}}

For loop with no stopping condition.

The return of main should be an int, but since it'll never reach the end this should compile. (Tested in VS 2015 and 2013, also works in Ideone). Thanks Geobits and MichaelS.

A shorter version, 35 bytes, can be achieved, but prints Process is terminated due to StackOverflowException which I believe violates the third point of not printing anything to stderr. Credit to MichaelB

class B{static int Main()=>Main();}

Perl 5, 9 bytes

while(){}

boooooooooooooooooooooooooooooooooooooooooring.

Perl 6, 7 bytes

loop {}

but...

> loop{}
===SORRY!=== Error while compiling <unknown file>
Whitespace required after keyword 'loop'
at <unknown file>:1
------> loop⏏{;}

Mouse16, 2 bytes

I hereby release the language I've been teasing!

0\

Goes to zero... which is the first byte... which executes the \ goto again... which -- well, you get the idea. This is like 10 GOTO 10 in BASIC.

Mmmm(), 56 bytes

mm=m[m.m()].m;mm=mm(mm(m.m()));m[mm].m(mm);<m[mm].m(mm)>

No, I have no idea how it works either.

GOTO, 9 bytes

M1:GOTOM1

Simply defines a label that goes to itself. GOTO seems to be Turing complete (by translation from a Minsky machine), so it should count as a programming language.

Dirst, 4 bytes

lpn_0

Loops as long as 0 is equal to 0.

KimL, 14 bytes

A:
ctrl.goto A

For whatever reason, labels must come before the lines that they label.

Skull, 8 bytes

for(;;);

Uses a bug in the Skull2C transpiler, where unrecognized expressions are converted directly into C.

Etre, 2 bytes

()

The program sets the first cell to 1, then loops while it isn't zero.

STXTRM, 2 bytes

;;

Program execution in this language is... strange.

ResPlicate, 5 bytes

1 4 2

After 1 step, this expands to 2 2 2 2, which is the smallest period 1 oscillator. That this is true was once the subject of a lengthy proof, which was thenceforth unceremoniously deleted when I pointed out that the fact was kind of a little bit obvious. I'm sure you can re-derive said proof yourself.

Spiral, 1 byte

All programs start at the label 0. All programs halt at the command !. Self-explanatory.

Mumps, 1 byte

Mumps being a very old language, most of it's commands and operators can be truncated to 1 or 2 letters. The [F]or command with no parameters defaults to an infinite loop until interrupted by a {CTRL}{C}. The flavour of Mumps that I use is InterSystem Caché.

𝔼𝕊𝕄𝕚𝕟, 2 chars / 4 bytes

↻;

I won't add a Try it here because you probably don't want to try it.

Befalse, 7 bytes

A two dimensional language.

Extremely straightforward; the ! unconditionally skips the next instruction and the / and \ reflect intuitively.

!/\
 \/

BASIC (QBasic 4.5), 10 5 3 bytes

In the BASIC programming language, RUN is used to start program execution from direct mode, or to start a overlay program from a loader program. - Wikipedia

Edit: This works without a line number in QBasic 4.5, according to @steenbergh

RUN

Here's the first version I posted. Infinite GOTO loop. Also, it's 10 bytes, which is a nice coincidence!

10 GOTO 10

beeswax, 3 or 4 bytes

A real loop (4 byte solution)

*PFJ

Explanation:

* Generate IP, moving to the right.                      [0,0,0]•
P Increment top local stack value.                       [0,0,1]•
F Set all local stack values to top local stack value.   [1,1,1]•
J Jump to [row,column] = [top,2nd] local stack values.   [1,1,1]•
  IP jumps back to to the *

Shorter 3 byte solution

I am not sure if reflecting IPs back and forth counts as loop, but here it is:

j*j

Explanation:

j Mirror IP in horizontal direction
* Create IP

So, this program creates two IPs moving to the right and the left, which are reflected back between both j’s indefinitely.

Quipu, 5 bytes

0&
??

0& pushes 0 as the current strand's value and ?? is an unconditional jump to that strand (which is the strand we're already on).

Aubergine, 6 bytes

:aa=ia

:aa is a no-op. =ia sets the IP to its own location.

QBasic, 8 7 bytes

DO:LOOP

Even shorter than the GOTO one!

V1.0

1:GOTO 1

Classical Goto.

ROOP, 1 byte

At the beginning, the number 1 is converted to an object that contains the number. As there is no operator and the object has nowhere to move, it always happens the same: nothing. The program does not end because there is an existing object.

Mouse, 5 3 bytes

()$

This is just a simple "while true do nothing."

Saved 2 bytes thanks to cat.

Emacs Lisp, 9 bytes

(while t)

Pretty straight-forward.

Go, 32 bytes

surprisingly long. surprisingly, never ends.

package main;func main(){for{}}

Fun fact: compiling this, due to the go tail-call and 03- optimising compiler, this generates an executable with absent .TEXT and .DATA sections.

Mouse-2002, 2 bytes

()

( begins a loop; ) ends it; there's no ^ so it never breaks.

AutoHotkey, 8 bytes

loop {
}

Previous answer posted in AHK was wrong and did not create a infinite loop.

Seed, 2 bytes

(note the trailing space character)

Any seed program consists out of 2 instructions, seperated by a space; The length of the Befunge program it will output and the seed which will generate that program.
Seeing how we need a Befunge program of length 0, we can create a Seed program with an empty 2nd instruction.

The Seed program 0 will output an empty Befunge program, which will run forever.

Interesting to note is that the Python compiler on the Seed esolang page is erroneous.
To create a Befunge program of length 0, any seed will do. That includes an empty seed. To stick to the spec however, the space after 0 is not omitted.

That being said, this is the world's shortest Seed program, and also the easiest to reverse engineer :-)

Javascript, 8 bytes

while();

This almost crashed my computer once :o

Arcyóu, 6 bytes

(@ 1 1

While 1: append 1. Note that this will blow the stack eventually, since it's slowly building a list of 1s in memory.

Marbelous, 7 bytes

00
\\//

One marble bounces between the two deflectors forever.

Alternate version:

00
/\/\

BASIC, 8 bytes

2 GOTO 1

A simple answer, but hey, it uses basic!

Also, for fun:

Brainf*ck, 3 bytes

+[]

Thue, 11 bytes

0::=0
::=
0

(Silly 30 character minimum)

ShapeScript, 8 bytes

'0?!'0?!

This requires the latest version of ShapeScript, since I have just implemented tail call optimization.

The online interpreter will exit quietly after one minute. Try it online!

How it works

'       Push a string that, when evaluated, does the following:
  0?      Push a copy of the topmost item on the stack (i.e., this string).
  !       Evaluate the copy.
'
0?      Push a copy of the topmost item on the stack.
!       Evaluate the copy.

Minecraft snap. Ver. 15w46a, 2 + 0 = 2 bytes

Note that this version of this "language" was created after the question was asked.

This is using this version of byte counting.

Put inside of an always active repeating command block, it will, indeed, loop forever with no output.

BotEngine, 2 bytes

><

Fairly self-explanatory.

Brian & Chuck, 7 bytes

#{?
#{?

The # could be replaced by any other characters except null-bytes or underscores.

The idea is fairly simple:

Brian moves Chuck's instruction pointer to the start ({) and hands control over to him (?).
Chuck moves Brian's instruction pointer to the start ({) and hands control over to him (?).
Repeat.

DStack, 3 bytes

skt

Language created by my few days ago

Befunge, 0 bytes

Yup. A Befunge program exists in a two-dimensional playfield with fixed size which wraps around the edges. With nothing in that space to interfere, the program counter runs in an infinite loop by default :)

Haystack, 2 bytes

v|

Haystack is a 2D-based grid language which starts executing in the upper left-hand corner. The characters <>v^ tells the "pointer" in which direction to go. It continues in the same direction until it hits another direction identifier or the needle |.

Seriously 0.1, 2 bytes

1W

1 pushes a 1 on the stack, W executes the code between it and the next W (or EOF) while the value on the top of the stack is a truthy value. Since the value on top of the stack stays 1, it NOPs forever.

Pyth, as of 11/3/15: 1 byte

There is no trailing space in this version. The requirement that statements have a value has been removed.

ಠ_ಠ, 31 bytes

ಠ4ಠ
ಠ4ಠ
ಠ1ಠ
ಠ?ಠ

Explanation

ಠ4ಠ # Push 4 to the stack [4]
ಠ4ಠ # Push 4 to the stack [4,4]
ಠ1ಠ # Push 1 to the stack [4,4,1]
ಠ?ಠ # Essentially: go to line 4

PoGo, 4 bytes

pogo

Explanation:

po - add current position in code to the top of the po stack
go - pop the most recent po location off the stack and jump there

PoGo uses an explicit call stack for flow control, the "po" stack. This code unconditionally jumps back to the beginning, producing an infinite loop. Note that it will not cause a stack overflow, the call stack will never contain more than one element.

Roadrunner, 14 bytes

mEEp mEEP MEEp

Underload, 6 bytes

Directly from the esolangs page.

(:^):^
(:^)     Pushes :^ to the stack.
    :    Duplicates the top of the stack
     ^   Pops the top of the stack and includes it in the command

Try it here using the stepping option to see it working

JacobFck

:A_A

Expanded and commented here

Hassium, 17 Bytes

Calls the main() infinitely.

func main()main()

Run online and see here

Half-Broken Car in Heavy Traffic, 5 4 bytes

^ov#

also in 4 bytes:

o
 #

x86 Machine code, 2 bytes

Machine Code

     00 01
0000 73 FE

Asm source

[SECTION .text]
[bits 16]
[org 0x100]

EntryPoint:
    jnc     EntryPoint

Both the jmp and the call instructions use a 1 byte op-code followed by a 2 byte absolute offset. Conditional jumps on the other hand, are limited to a destination within [+127, -128] bytes of the branch. This is because they are encoded with a 1 byte op-code and a 1 byte relative offset. Dos already cleared the flags before invoking our program, so we know the carry flag will be clear and facilitate an endless (non-crashing) loop. We wont run out of stack-space, which would result in a stack-overflow error, or overwriting and ultimately crashing, our program. Approaches using call will suffer this after about 32,638 iterations. (stack is initally 0xFFFE, (3 byte) program begins at 0x100, each iteration decrements the SP by 2.)

Perl 6, 7 5 bytes

The standard boring one is just an empty loop (;;){} construct.
( spelled for(;;){} in other languages )

loop {} # 7 bytes

There are also exotic ones as well

infinite sequence of the Any type object ( default value in $_ )
```
.roll(*) # 8 bytes
```
unterminated sequence generator (0,1,2,3,4 ... Inf, Inf, Inf, Inf)
```
0...* # 5 bytes
```

PowerShell, 14 7 Bytes

for(){}

Previous version (14 bytes):

while($true){}

Minkolang, 1 byte

A language inspired by space-time has to have at least SOME space! It's also worth noting that this particular 2D infinite loop is unique in that it's actually looping through time. That is, it's falling through the layers (of which there is only 1) of the program, which is toroidal.

Univar, 8 bytes

($,,)$,,

Self-calling function.

Gema, 18 15 characters

\A=@a{a};a:\P?=

Sample run:

bash-4.3$ gema '\A=@a{a};a:\P?='

Burlesque, 5 bytes

0bc<-

Trying to reverse an infinite list is guaranteed to loop forever and since it loops forever no output will be produced ever.

GOLF, 10 bytes

didn't see a golf response

lx:
jmp lx

lx: sets a goto marker, jmp sends you to the marker. Note that the marker name cannot be a single character (as far as I know) because the alphabet characters are reserved for registers.

x86 Assembly, 3 Bytes

Inspired by this post

E8 FD FF

is the same as

label: call label

even better, write it to your boot sector to make your computer ~~unbootable~~ faster!

AppleScript, 10 Bytes

In Script Editor... it's 10 bytes, which is way better than I expected nonetheless.

repeat
end

Thanks to @Mark for pointing out that the 0 byte "loop" was no loop at all.

C++ Template Meta-Programming, 48 bytes

template<int n>class S{enum{v=S<n-1>::v}}S<1>::v

There is an infinite loop in the template, so this doesn't compile. Other stuff that doesn't compile, but doesn't need to for the template to recurse (S being private, S<1>::v being free floating)

Can be run at http://coliru.stacked-crooked.com/ for error g++: internal compiler error: Segmentation fault

g++ -std=c++14 -O2 -Wall -pedantic -pthread -ftemplate-depth=162345 main.cpp && ./a.out

ArnoldC, 61 bytes

IT'S SHOWTIME
STICK AROUND 1
CHILL
YOU HAVE BEEN TERMINATED

Ironic how the program never actually terminates, even though the last line says "YOU HAVE BEEN TERMINATED."

OCaml, 17 bytes

while 1<2do()done

1 byte removed thanks to @Mauris.

Another one bytes the dust thanks to @feersum.

HPPPL, 16 bytes

while 0=0 do end

PARI/GP, 9 bytes

while(1,)

Or equivalently:

until(0,)

Staq, 2 bytes

()

( jump to corresponding ) if the top stack value is greater than 0

) jump back to corresponding ( if the top stack value is 0 (or if it does not exist)

Cardinal, 2 bytes

%$

$%

In Cardinal each pointer carries exactly 2 unsigned 8 bit values, one active, one inactive. Both are initialized to 0

% creates 4 pointers moving in the cardinal directions.

$ moves the pointer to x,y = active,inactive value of the pointer

ShadyAsFuck, 2 bytes

a]

This starts a for loop that never increases or decreases. This can also be represented by

+(

As this is a substitution language for Brainfuck (and there is a more popular answer in that language for this already), please do not consider this for the winning code.

Pyth, 3 bytes

W1

Note that there is a space after W1.

MIPS, 6 bytes

I didn't use mips for ages, but if i remember correctly, it will be something like that : a: j a;

HP48's RPL, 18 bytes

« DO UNTIL 0 END »

You may remove the spaces around the « and » but the calculator will add them again for you.

That's the source size; "binary" size when stored in the calculator is actually longer (25.5 bytes).

TIS Node Type T21 Architecture, 6 bytes

A single node with NOP written in it

Tessellated Intelligence System nodes are classified as "processing" or "storage" nodes. Storage nodes simply store and retrieve information, and are irrelevant in this case. Remaining are the processing nodes. Node Type T21, or Basic Execution Node, is the most common and simple (as the name would suggest).

Technically, each node can be thought of as an independent computer. In the case of the T21, it is a computer that has two storage registers (one addressable, one not) and an instruction set of 15 commands. It has enough memory to be programmed with up to 15 instructions. All TIS nodes have four ports connecting them to the topologically adjacent nodes. Reading from a port causes that node to hang until the node on the other end writes to it, and writing to a port hangs until that node reads it.

You might be able to tell by now that TIS nodes were never meant to do much on their own. Together, though, they can be quite powerful... well, for their time. Because of these limitations, it's very rare to see someone use only a single node. In fact, a program that takes input and provides output based on it must use at least three nodes, as TIS systems feed input into the UP port of a node on the top row and take output from the DOWN port of a node on the bottom row. There are three rows, so data must pass through at least three nodes to get to the bottom.

Because of these limitations, TIS nodes are intended to generally be used somewhat like this:

Get input
Do something to it
Pass it on
Return to step 1

Because of this, the limited space for instructions and the fact that nodes simply wait quietly and don't cause trouble when trying to read input that isn't there, a decision was made in their design that makes them very good for this challenge. I'll quote from the TIS-100's reference manual:

After executing the last instruction of the program, execution automatically continues to the first instruction.

Perfect! Infinite loops are default for TIS nodes.

I very nearly answered this question with a 0 byte answer, claiming that an empty node was an infinite loop. However, I researched further. First, the quote above states that the loop occurs after executing the last instruction. Additionally, I tested the implementation. Each node reports a "mode" at all times. It isn't accessible programmatically but it's intended to make debugging easier. Here are the possible modes:

 RUN‌ - I am executing an instruction.
READ - I am reading from a port, waiting for it to be written to.
WRTE - I am writing to a port, waiting for it to be read from.
IDLE - I am doing nothing.

It turns out that, since each node is an individual computer, they are capable of determining whether or not they have instructions to execute. If not, they remain in the IDLE state (likely to save power). As such, I couldn't in good conscience claim that it was "looping"; rather, each node sat quietly, assuming the others were doing something important.

This program that I've submitted is truly an infinite loop, as executing it sets the state of the node to RUN. It is as simple as you would expect, NOP performs No OPeration. Once it's done doing nothing, execution returns to the top of the code: NOP.

If you find it unsatisfying that I'm abusing the T21 architecture to create a loop, I offer an alternate solution at the cost of 2 bytes: JRO 0. JRO means Jump Relative uncOnditionally. Or something, I guess. There's no agreed-upon expanded form of the instructions. Anyway, JRO takes a numeric argument and jumps execution by that amount relative to the current position. For example, JRO 2 skips the instruction that follows it (useful if that instruction is jumped to from somewhere else). JRO 1 jumps forward one instruction, making it a NOP. JRO -1 jumps back one instruction, effectively performing the previous instruction once every two cycles until the program is halted. And, of course, JRO 0 jumps to itself, executing itself forever.

At this point you may be thinking:

Sure, monorail, this all makes sense, but your answer is simply NOP. Why is its score 6 bytes?

Good question, thanks for asking. One may naively think that TIS programs should be counted the same way we count programs in multiple files: the number of bytes in all nodes, plus 1 byte for each additional node after the first. However, the TIS golfing community decided this would be unfair for the simple reason that it ignores some of the information required to recreate solutions. A node's neighbours are very important, and that scoring method gives you positional information for free. Instead, we've adopted the format used by the most common TIS emulator, the confusingly-named TIS-100. (Side note: Please don't name emulators after the system they emulate. It's not clever, it's just annoying and makes everyone have to constantly clarify what they're talking about.) It's very simple: The 12 nodes of a TIS-100 device are numbered, left to right and top to bottom, skipping any storage nodes the emulated system has installed. A node numbered N containing # CODE\n# CODE\n CODE is saved like so:

@N
# CODE
# CODE
# CODE

And so, a node numbered 0 containing NOP is scored according to its representation in this format:

@0
NOP

Six bytes.

As I often include in my answers in visually-interesting languages, you can watch the TIS-100 emulator execute this program on YouTube. Though, considering what this challenge is, I don't know what you expect to see...

8085 Intel Microprocessor ,4 1 byte

0000h: pchl

whose machine code is:

E9

Just reset the microprocessor. And load E9 at 0000h.

p.s: its almost impossible in some kit to load program at ROM memory(which is basically the start memory) So, it works on simulator and some special kits only.

C000H: lxi h,C000h
C003H: pchl

whose machine code will be

21 00 0C E9

loaded in memory from C000H

><>, 1 byte

A single space will cause ><> to go into an infinite loop of NOPs

Other valid single character programs (with no memory requirements) are as follows:

>^v</\|_#x!"'{}r

In addition, the rules state that your program can run out of memory in which case we can add the following characters to the list of valid 1-byte programs:

01234567890abcdefli

Coffee Script, 9 8 bytes

1while 1

GOTO++, 19 bytes

§1 GOTOPASMALIN %1

§1 is the label 1

GOTOPASMALIN is a deterministic goto instruction that goes to the label X specified with the argument %X.

goto pas malin literally means Not-clever goto in French. It is named this way because there are keywords in GOTO++ to do goto at random, on a random label in a list, etc.

Delphi, 35 bytes

program P;begin while true do;end.

Managed to beat C# this time :)

Piet, 2 Codels

2 Codels is as small as a loopy Piet program gets.
With only 1 codel the 8 waits needed for a finish would be immediatly met.

In the example (10 pixel codelsize) the difference between the 2 colours are +2/-2 Hue delta and +2/-2 Light delta. So it keeps on repeating a "roll" "not".

pb, 8 bytes

In pb, the shortest possible infinite loop is 8 bytes long. In fact, there are sixty 8 byte infinite loops, none of which produce output! (Unless you're running in watch mode, which is intended for debugging, no pb programs produce output until they halt. However, even if one of these did eventually halt, no output would have been produced.) Here are the sixty shortest infinite loops, in alphabetical order:

w[B!1]{}
w[B!2]{}
w[B!3]{}
w[B!4]{}
w[B!5]{}
w[B!6]{}
w[B!7]{}
w[B!8]{}
w[B!9]{}
w[B=0]{}
w[C!1]{}
w[C!2]{}
w[C!3]{}
w[C!4]{}
w[C!5]{}
w[C!6]{}
w[C!7]{}
w[C!8]{}
w[C!9]{}
w[C=0]{}
w[P!1]{}
w[P!2]{}
w[P!3]{}
w[P!4]{}
w[P!5]{}
w[P!6]{}
w[P!7]{}
w[P!8]{}
w[P!9]{}
w[P=0]{}
w[T!1]{}
w[T!2]{}
w[T!3]{}
w[T!4]{}
w[T!5]{}
w[T!6]{}
w[T!7]{}
w[T!8]{}
w[T!9]{}
w[T=0]{}
w[X!1]{}
w[X!2]{}
w[X!3]{}
w[X!4]{}
w[X!5]{}
w[X!6]{}
w[X!7]{}
w[X!8]{}
w[X!9]{}
w[X=0]{}
w[Y!1]{}
w[Y!2]{}
w[Y!3]{}
w[Y!4]{}
w[Y!5]{}
w[Y!6]{}
w[Y!7]{}
w[Y!8]{}
w[Y!9]{}
w[Y=0]{}

These all follow a simple pattern. w is a while loop, pb's only looping or branching instruction. Inside the square brackets is the condition, which is two expressions separated by ! or =. To understand what this means, imagine an extra = just before the second expression. In the same way that you understand 2+2==4 to be true and 10!=5*2 to be false, 2+2=4 and 10!5*2 are true and false in pb. A while loop is executed until the condition becomes false. Finally, there is a pair of curly braces containing pb code. In this case, there's no code to be run, so they are empty.

The important thing here is the condition. pb has six variables, all for different purposes. They are:

B - The value of the character under the brush
C - The colour of the character under the brush (from a lookup table, the important thing being that white = 0)
P - The current colour that the brush is set to output in (same lookup table)
T - Set by the programmer, initialized to 0
X - X position of the brush
Y - Y position of the brush

The brush starts at (0, 0) on a canvas that is entirely initialized to white null bytes. This means that all of the variables start out being equal to 0.

These sixty programs fall into two categories: 10 loops that are executed until a variable (equivalent to 0) stops being zero, and 50 loops that are executed until a variable (equivalent to 0) becomes a specific non-zero number. An infinite number of programs can be written that fall into that second group, but only 50 are the same length as the 10 in the first one.

Mornington Crescent, 117 106 Bytes

Take Northern Line to Bank
Take Circle Line to Temple
Take Circle Line to Bank
Take Northern Line to Angel

There appear to be some bugs in the Python interpreter, but the language's creator has a C# interpreter that works for this code.

*Inspired by @ETHproductions

EDIT: Since it doesn't ever terminate, can remove required return to Mornington Crescent

Thanks Martin Büttner for 8 bytes, and Timwi for 3 bytes.

Emily, 12 bytes

while^(1)^()

I was a character short of 30 for the body of this post. :/

Turing Machine Code, 9 bytes

As usual, I'm using the rule table syntax defined here.

0 _ _ * 0

"When in state 0, upon reading an empty cell, replace it with an empty cell, don't move, and transition to state 0."

Factor, 14 bytes

: a ( -- ) a ;

and nicely symmetrical looking (almost)

Emmental, 18 11 bytes

;#35#63#!#?

Emmental is a self-modifying, stack-based language. It has no built-in looping operator, so we have to make our own. Here's what the relevant commands mean (taken from the Esolangs wiki page):

; - Push the symbol ; onto the stack.
# - Push NUL (ASCII 0) onto the stack.
0..9 - Pop a symbol, multiply its value by 10, add 0..9 respectively, and push the result.
! - Pop a symbol and an Emmental program (a string of symbols terminated by ;). Then redefine that symbol as having the same semantics as that Emmental program.
? Pop a symbol and execute it. This is similar to eval.

So, what does this program (created by @Sp3000) actually do? Well, it redefines NUL to mean #? (push NUL and execute it), then executes NUL. This sets off a domino-like effect where NUL executes NUL executes NUL executes NUL...you get the picture.

I'm no expert on Emmental, but there may be an even shorter way to loop infinitely. Suggestions welcome!

Funciton, 72 bytes

Encoded in UTF-16.

I cannot think of a smaller Funciton program that would run forever. It consists of a declaration of a function that calls itself and a main program that calls said function on STDIN. Is it possible to do shorter?...

┌─╖╓─╖┌─╖╔╗
┤∞╟╢∞║┤∞╟╢║
╘═╝╙─╜╘═╝╚╝

Sclipting, 6 bytes

Encoded in UTF-16.

到終

This is a while-false loop with an empty body. This assumes that the program input is falsy, but I interpret the problem statement as saying that the input will be empty, so this is fine.

Ziim, 14 bytes

Encoded in UTF-16. (UTF-8 without BOM is 16 bytes...)

↘↙↙
↑↑

AT&T (PDP-11) Syntax Assembly: 4 bytes

br .

PDP-11 UNIX A.OUT binary output: 24 18 bytes

0000000  000407 000002 000000 000000 000000 000000 000000 000000
0000020  000777 000000 000000 000004
0000030

This is the output produced by the assembler. As the sizes in the header show, the last three words are not necessary, it can be cut down to the first 18 bytes.

Some modern assemblers do not support the br instruction, so it would be five bytes for jmp .. And executable headers are generally much bigger these days.

Linux x86-64 binary output, after strip: 336 bytes

Now, OSX's assembler is much more strict. You must have a symbol (by default start, but here I use f) for the entry point, which balloons the size of the source. It also requires a newline at the end of the file.

Mac OS X x86-64 Assembly: 17 bytes

.globl f
f:jmp f

Mac OS Mach-O Binary Output: 4200 bytes

NASM/YASM x86 assembly, 4 bytes

ja $

$ is the address of the current instruction, and ja jumps there if the carry and zero flags are both unset. (i.e. the Above condition is true.) This is the case in x86-64 Linux at process startup.

ja$ just defines a symbol, instead of being an instruction, so the space is not optional. I did test that this works without a trailing newline, so it really is 4 bytes.

Assemble/link with

$ yasm -felf64 foo.asm && ld -o foo foo.o
ld: warning: cannot find entry symbol _start; defaulting to 0000000000400080

The x86-64 ABI used by Linux doesn't guarantee anything about the state of registers at process startup, but Linux's actual implementation zeroes all the registers other than RSP for a newly-execed process. EFLAGS=0x202 [ IF ], so ja (jump if Above) does jump, because the carry and zero flags aren't set. jg (ZF=0 and SF=0) would also work. Other OSes that initialize flags differently might be able to use one of the other one-letter conditions that require a flag bit to be set: jz, jl, jc, jp, js.

Using ja instead of jmp (unconditional jump) makes the source one byte shorter, but the binary is the same size (2 bytes: one opcode byte, one rel8 displacement, for a total size of 344 bytes for a stripped ELF64 binary. See casey's answer for a 45 byte ELF executable if you're interested in small binary size rather than small source size.)

R, 8 bytes

repeat{}

I believe this is the shortest way to make a loop that won't stop. We would need an infinite length list to use a for loop and while(T) is longer than repeat.

Vim, 7 keystrokes

Open the editor, preferably without any loaded scripts, for instance like like this from the command line: vim -u NONE

qq@qq@q

Vimscript, 15 8 bytes

Add it in a script, or run it directly by punching the colon (:) key first while you're in normal mode

wh1|endw

Octave, 10 bytes

1 byte shorter than @flawr's answer ...

do until 0

(Haven't tested it in Matlab though...)

Insomnia, 2 bytes

HY

It encodes the sequence of instructions: 7289

Although it's not clear whether instruction 8 checks the content of the bit pointer or the group pointer, the code above works in either cases, since the content of the bit or the content of the group is always non-zero.

D , 21 bytes

void main(){for(;;);}

No language used with D in it name.

Rust, 17 bytes

Didn't see one in rust so:

fn main(){loop{}}

real original and interesting and so different from all the other entries.

PHP, 10 8 bytes

The for(;;) solution has been posted enough, Time for this one:

while(1)

~~while(1){}~~

MarioLANG, 3 bytes

!
=

I found several other solutions, but they seem to be bugs in the Ruby interpreter rather than features of the language (e.g. replacing ! with @). This one actually seems to work intentionally. = is just a ground cell for Mario to stand on, and ! instructs him to stop walking. So he just stands there, waiting for something to happen, which of course doesn't. (The usual purpose of ! is to use it on elevators, such that Mario remains in place while the elevator moves to its target position.)

Prelude, 3 bytes

1()

Any other non-zero digit could replace the 1. This is essentially the same as the Brainfuck solution (just adding it for completeness).

Poslin, 20 bytes

[ .true ! | ]while !

This does the part between | and ] as long as the part between [ and | returns the true value.

.true ! creates the true value at compile time.

[ .true & | ]while !

works just the same, but here the operation .true is called on every iteration.

C, 16 bytes

main(){for(;;);}

A simple C loop construct. A for loop does not require curly brackets.

SmallTalk – 18 bytes

[true]whileTrue:[]

PHP, 8 bytes

for(;;);

When running from command line (-r argument) you don't need php openning/closing tags.

Ex.: php -r "for(;;);"

3var, 2 bytes

{}

To quote the docs:

{   Starts a loop which repeats forever
}   Ends a loop which repeats forever

Groovy, 8 bytes

for(;;);

Shortened from the original thanks to suggestions. The trailing semicolon is still required, unfortunately.

while(1){}

Fortran, 11 bytes

It is not very creative, but here is the shortest I found:

1goto 1
end

I am pretty sure this is not standards compliant, but it compiles with ifort.

Carriage, 30 bytes

111-@11-~!$11111++++11-~@11-~!

CFL 2 (ComeFrom 2), 17 bytes

10 comefrom 20
20

Try it here.

Batch, 3 bytes

@%0

Microchip PIC Machine Code, 0 bytes

An unprogrammed/erased PIC will by default have the program memory (flash) contain all NOP instructions. NOP does nothing.

Now, NOPs by themselves don't implement infinite loop. But the PIC program counter by design wraps around back to zero. Therefore, an unprogrammed/erased PIC executes an infinite loop.

Note: This is true for a lot of CPU architectures. Especially microcontrollers.

Rail, 11 bytes

$'main'
@-@

Rail starts at the $ of the main function, heading southeast. We hit -, which makes the train turn and move eastward. After that it's just bouncing all night long between two @ reflectors.

SQL (SQL Server 2008+), 92 bytes

WITH R AS(SELECT 1N UNION ALL SELECT N*1FROM R)SELECT*FROM R WHERE N<1OPTION(MAXRECURSION 0)

I feel ~~a little~~ dirty putting this up, but my original thought was that this wouldn't be possible with a SQL query. With something like T-SQL or PL/SQL not a problem, as a query though? The obvious answer was a recursive query with no recursion limit set. But how to get it to run without outputting anything. My initial tests using queries like

WITH R AS(SELECT 1N UNION ALL SELECT N FROM R)SELECT*FROM R WHERE N=0OPTION(MAXRECURSION 0);
WITH R AS(SELECT 1N UNION ALL SELECT N FROM R)SELECT*FROM R WHERE N<1OPTION(MAXRECURSION 0);

showed that the optimizer would cause the query to exit immediately with no rows returned. Using N+1 allowed it to loop, but I suspect that the integer would eventually overflow. I used N*1 in the query to avoid that and trick the optimizer into letting it run without short cutting out. I've let it run for a few minutes on my machine and it didn't seem to start consuming memory, but I can't guarantee that wouldn't happen.

z80 Machine Code, 1 byte

c7       ; RST 00h

Or if assuming the code starts at 0000h is cheating, two bytes:

18 fe    ; JR -2

These solutions make no assumptions about the rest of the environment's RAM. If it's filled with zero bytes, we are just spinning through NOPs forever, so we could have a 0-byte solution. (Thanks to Thomas Kwa for pointing this out.)

Labyrinth, 1 byte

A labrinth program executes the same instruction over and over again if there are no neighbors. They also won't end until they execute the @ instruction.

Aheui, 0 bytes

Aheui is a Befunge-like, and the empty program is an infinite loop for exactly the same reason.

Lazy K, 8 7 bytes

SISSSII

Reduces to the lambda expression (λx.x x) (λx.x x) which has no normal form.

Starry, 9 bytes

`      +'

Loops in Starry are written with ` (which marks the current location in the code as label n, where n is the number of spaces in front of it) and ' (which pops a value from the stack and jumps to label n if that value was non-zero). So we use these two n = 0. But that leaves the question how to get a non-zero value onto the stack. I believe the shortest way to do is simply to push a 1, which requires 6 spaces and a +.

Scheme, 12 bytes

A tail-recursive infinite loop seems most appropriate for scheme :-)

(let l()(l))

even though (do(())()) (the CL variant of which is due to @JoshuaTaylor) would be 2 bytes shorter.

Javascript (8 bytes)

for(;;);

Edit courtody of @KritixiLithos

Javascript (10 bytes)

while(1){}

Fourier, 3 bytes

1()

Repeats until the result of the loop equals 1, which it never does.

Pip, 3 bytes

W1x

Basically a while 1: 0 answer.

A more interesting 2-byte solution that doesn't quite fit the rules:

Vf

f is the current function; V evaluates it. This theoretically goes on forever, but in actuality it ends up causing infinite recursion in the interpreter, which very quickly exits with

Fatal error: maximum recursion depth exceeded while calling a Python object

Oh well.

AHK, 4 bytes

loop

quick and simple

Unlambda, 7 bytes

``ci`ci

Try it here. It uses c (call-cc) which is a little magical.

FlogScript, 2 bytes

F<

The F< (flow-control-restart) command repeatedly restarts the program.

RoboTalk, 5 bytes

0 rti

RoboTalk has three "goto" instructions: jump, return, and rti. Jump and return are plain "go to the address on the top of the stack" instructions, while rti has the side effect of (re-)enabling interrupts, as it's intended to be used to exit interrupt handlers. In a robot without any interrupt handlers defined, however, it is functionally equivalent to the other two instructions while being one byte shorter than jump.

Pyth, 2 bytes

I think the only solutions are '# ', which has already been posted, and the f based solutions:

f0
fk
fH
fY
fZ
f"
f[
f(
f{
f]

f followed by anything falsy.

Whitespace, 9 bytes

;
...; create label [space]
;
.;
.    goto label [space]

. represents a space and ; represents a newline character.

F#, 14 bytes

while 0<1 do()

Self-explanatory.

Fission, 1 byte

There are exactly 4 one-byte solutions:

These four letters indicate that an atom starts there (in the corresponding direction). One of them is required because without an atom the program terminates immediately. Since the source code is only one character in size, the atom will wrap around immediately, and execute the same cell again. However, after the beginning of the program UDLR simply act to deflect an incoming atom in the corresponding direction, so they become no-ops in this case.

Perl, 4 bytes

do$0

Executes itself repeatedly.

Malbolge, 1 byte

A single-space program causes Ben Olmstead's reference implementation to loop forever. Can you find out why?

Burlesque, 2 bytes

bc

The BoxCycle command. Essentially takes whatever string s is on STDIN and tries to evaluate the infinite list [s, s, s...]

gs2, 2 bytes

CP437: ►3

Hex dump: 10 33

Tries to split whatever is on STDIN into chunks of length 0. We never actually split off any chunks, not even from an empty string, so this takes forever.

Note that gs2 doesn't have any traditional looping constructs.

(Mitch Schwartz found this and told me about it, and I thought it was a really cute feature.)

COBOL, 51 bytes

ID DIVISION.PROGRAM-ID.A.PROCEDURE DIVISION.B.GO B.

C++, 15 bytes

Same as C:

main(){main();}

APL, 8 5 4 bytes

-⍣=1

This repeats negation until the result is equal to the previous input (beginning at 1) which can't happen, so it loops indefinitely.

Saved 3 bytes thanks to Dennis and 1 thanks to jimmy23013!

Go, 31 Bytes

package main
func main(){for{}}

Nothing special, the for loop without header runs infinitely.

Pascal, 32 bytes

program l;begin while 1=1do;end.

A full program in just one line.

program l;: Start a new Pascal program
begin: Begin a code section
while 1=1do;: Do nothing (; / NOP) as long as 1=1, which shorter than true. Identifiers (do for instance) are not allowed to begin with a digit, so we can omit the space here and save one byte.
end.: End the code section

ZX Spectrum BASIC, 2 bytes

1 RUN

The program will never run out of memory :-)

Explanation:

There is no space between the line number and the command, it is just a visual clue displayed when LISTing the program
The keyword RUN is one byte, in Sinclair BASIC the keywords were really just a single characters (with codepoints >=128), that just happened to look like multi-character words when displayed. In particular, you enter the keyword by pressing one key, the one with the keyword on it, and it enters one byte.

The internal representation is a bit longer (line number is stored as two bytes), but isn't this true for almost all the languages? :-)

StackStream, 21 bytes

{ dup exec } dup exec

Kind-of explanation thingy:

{ dup exec } # Push this piece of code onto the data stack.
dup # Duplicate it (stack: { dup exec } { dup exec })
exec # Execute it (stack: { dup exec })

VBScript, 17 bytes

do
loop while 1

Recall, 2 bytes

Yy

Since there is no break operator, it will loop forever. You can try it here. Of course it will freeze the tab.

k, 4 bytes

~:/1

How it works

In k, / iterates the function on the left starting with the argument on the right until the result repeats. The ~: is a "not" function which turns 1 into 0 and 0 into 1 repeatedly in this code.

Objective-C, 1716

-(id)a{for(;;);}

STATA, 10 bytes

while 1{
}

Apparently for loops in STATA always halt, but while loops can be infinite.

ferNANDo, 7 bytes

1 1
1
1

Line 1 initializes 1 to 1, line 2 marks the beginning of the loop, and line 3 marks the end (a single variable statement loops back to the previous occurrence, if any, for as long as the variable is true).

C++ 11 template metaprogramming, 58 54 bytes

template<int>struct I{int v=I<1>{}.v;};int a=I<1>{}.v;

C++ helpfully comes packaged with 2 other turing complete languages: the C preprocessor, and template metaprogramming. Note that this does reach a max recursion depth at some point, but the OP clarified that this is okay.

Example run:

g++: internal compiler error: Segmentation fault (program cc1plus)
Please submit a full bug report,
with preprocessed source if appropriate.
See <http://gcc.gnu.org/bugs.html> for instructions.

A POSIX OS's program loader, 14 bytes

#!/usr/bin/env

VBA (immediate pane), 14 bytes

This will freeze up the VBE and its host app:

do:loop

Basilisk, 5 bytes

:A1gA

Pretty simple.

Explanation

:A

Defines position A.

1gA

Pushes one and goes to position A in code. Since the gA pops the top value in stack, if the loop were ever to end, it would not print anything.

C, 17 bytes

main(){l:goto l;}

Why not for(;;);? Because goto are cool.. and 17 is a nice number

Python, 9 bytes

Works in both 2 and 3.

while 1:0

Shortened by @FryAmTheEggman

JavaScript, 8 bytes

NOTE: This is the same as the existing Processing answer; just posting it for the sake of catalogue completeness.

for(;;);

Bonus: Here's a 12-byte ES6 alternative, using recursion instead:

a=_=>a();a()

CoffeeScript, 6 bytes

loop 0

Interesting fact thanks to Martin Büttner, not sure if there's any practical use to it though.

Previous attempt (8 bytes):

1while!0

There is only a while loop, no for (though there are for..in and for..of).

Haskell, 9 bytes

Infinite recursion of the main function. Should get compiled to a loop due to tail recursion optimization.

main=main

Julia, 13 12 bytes

while 1<2end

Yawn. I tried a map and a for loop, but to no avail...

EDIT: Someone pointed out that I could shorten the program by removing parentheses. Thanks!

Alternatively, if stack-overflowing infinite recursion counts as infinite (11 bytes):

i()=i();i()

Matlab/Octave, 11 bytes

while 1;end

(tested)

HALT, 7 bytes

1 SET 1

This set's the pointer to 1, this is run forever because there is no HALT; command. This will bybass fail-safes to prevent infinite looping.

Try This

Lua, 11 bytes

In Lua, you can set labels that can be used with the goto statement!

::y::goto y

PowerShell, 7 bytes

for(){}

...

C, 15 bytes

main(){main();}

Yes, it's possible to call main() recursively. If you've got a compiler that does tail-call optimization (say, gcc with the -O2 option), it doesn't even segfault: the compiler is smart enough to turn the function call into a goto.

FlogScript, 6 bytes

This creates a string containing code for duplicating the top value on the stack, then popping it and executing it as code. Then it is duplicated, popped, and executed as code.

{.~}.~

AutoIt, 10 bytes

Do
Until 0

Lame.

Perl, 6 bytes

perl -e '{redo}'

From perldoc -f redo:

The redo command restarts the loop block without evaluating the conditional again...Note that a block by itself is semantically identical to a loop that executes once. Thus redo inside such a block will effectively turn it into a looping construct.

I don't see redo too often in production code, but it's great for golf! Compare the above to the shortest equivalents with for, while, and goto:

for(;;){} # 9 bytes
1while 1  # 8 bytes
X:goto X  # 8 bytes

Rust, 17 chars

fn main(){loop{}}

Nothing much interesting to see here.

Macaroni 0.0.2, 14 chars

label a goto a

Fairly self-explanatory...

Snowman 1.0.2, 6 chars

~:1;bD

~ sets all the variables to active, :...;bD is a "do" loop (i.e. continues looping while the block returns a truthy value), and 1 is 1.

MSM, 2 bytes

ee

Almost all 2 character strings will work, even two spaces, just don't use any of the following 6 commands :,/.?'.

Self-modifying Brainfuck, 3 bytes

Same effect as in regular BF. Increment the cell and loop forever. -[] is the same.

+[]

Since the source code in placed on the tape, this is also acceptable, and only works in SMBF:

<[]

If the tape were actually infinite, [ or ] would work, since the interpreter would search for the matching bracket forever. Unfortunately (fortunately?), you just get an "index out of bounds" error.

Ada, 49 47 bytes

procedure L is begin loop null;end loop;end L;

I'm guessing there aren't many Ada entries on Code Golf!

Naturally it should look like

procedure L is 
begin 
   loop 
      null; 
   end loop; 
end L;

and do exactly what it says on the tin.

R, 9 8 bytes

repeat 1

Saved 1 byte thanks to MickyT!

Math++, 3 bytes

1>$

Basically a GOTO 1 statement- on line 1.

bash + BSD coreutils, 23 22 14 6 5 6 bytes

yes>&-

yes outputs "y" forever; >&- closes STDOUT.

Thanks @Dennis and @ThisSuitIsBlackNot for help getting the size down!

Beam, 2 bytes

There is a few ways of doing this from the very basic

><

to the very basic

>?

and

>|

GNU sed, 3 bytes

:;b

Using this meta answer as justification for the relaxation of the no-input rule.

: defines a (nameless) label, ; is a line/command separator, b jumps to the label.

Nameless labels seems to be a GNU extension.

GNU dc, 6 bytes

[dx]dx

Tail recursion FTW, which GNU dc supports. Others might not.

Swift, 12 bytes

while(1>0){}

BBC Basic for Windows, 3 or 6

http://www.bbcbasic.co.uk/bbcwin/bbcwin.html

RUN

3 ASCII characters. Note in this version of BBC basic line numbers are not required.

If you don't consider termination and self-execution a loop, then the shortest program is

1GOTO1

6 ASCII characters.

One might expect these to be shorter in the tokenized version (1 byte per keyword), but it seems they are not, due to the way line numbers / internal ID's are stored.

X86/X64 Machine Code, 2 bytes

Hex dump:

0xEB 0xFE

Disassembled source code:

f:jmp f

Basically, because the entry point _start isn't defined, ld defaults to the address that is coincidentally the location of f.

MUMPS, 1 byte

This is the equivalent of for ( ; ; ) ; in C-like languages. It runs from the prompt as is, though, and does not need to be wrapped in a function declaration or any such thing.

x86 Intel Assembly (NASM), 5 bytes

jmp $

LOLCODE, 24 bytes

IM IN YR X
IM OUTTA YR X

AutoIt3, 12 bytes

While 1
WEnd

Simply loop indefinitely. Nothing much to say.

rs, 3 bytes

+/1

Note that this will eventually run out of memory...

Foo, 3 bytes

(1)

Everyone's favorite programming language! :D

Scala, 12 bytes

while(1>0){}

Spin, 13 Bytes

File x.spin:

pub x
 repeat

(without trailing newline)

Compile and download it to your P8x32a microcontroller or run it using spinsim.

Common Lisp, 6 characters

(loop)

Hexagony, 1 byte

I don't know much about this awesome language created by @MartinBüttner, but from what I've seen, this should loop infinitely, as there is no @ to halt the program. . is simply a no-op.

CJam, 4 bytes

1{}h

Put a 1 on the stack, and loop until 1 is no longer truthy. Using h means that the number is never popped.

L00P, 0 bytes

This lang was made for looping, and that's just what it'll do...

Processing, 8 bytes

for(;;);

This is based on Geobit's answer in Java

Although the code below is not the shortest, it is one of Processing's specialties.

void draw(){}

This draw statement repeats itself over and over again. It is one of the differences between Processing and Java.

GolfScript, 3 bytes

1do

For obvious reasons, this does not work in the online interpreters.

Pyth, 2 bytes

Pyth expects tokens after the forever operator. (That's a space.)

Ruby, 6 bytes

Pretty self explanatory. Ok, my post is long enough now.

loop{}