11l

360 Assembly

* An asterisk in column one denotes a comment line* Comments may also follow any syntactically complete instruction:          LA    1,0           Comment          NOP                 Comment (after a NOP instruction)* Comments after instructions with omitted operands require a comma ","         END   ,             Comment (without comma, "Comment" assumed an operand of "END")

4D

`Comments in 4th Dimension begin with the accent character and extend to the end of the line (until 4D version 2004).// This is a comment starting from 4D v11 and newer. Accent character is replaced by //

4ME

Normal 4ME

Rewriten 4ME

6502 Assembly

          nop           ; comments begin with a semicolon

68000 Assembly

MOVEM.LD0-D7/A0-A6,-(SP);push all registers onto the stack

8086 Assembly

MOVAX,4C00h; go back to DOSINT21h; BIOS interrupt 21 base 16

AArch64 Assembly

/* ARM assembly AARCH64 Raspberry PI 3B *//*  comments multi lines    end comments    */               // comment end of ligne

ACL2

; Single line comment#| Multi-linecomment |#

Action!

;This is a commentPROC Main() ;This is a comment as wellRETURN

Output:

ActionScript

Ada

-- All Ada comments begin with "--" and extend to the end of the line

Agena

# single line comment#/ multi-line comment   - ends with the "/ followed by #" terminator on the next line/#/* multi-line comment - C-style   - ends with the "* followed by /" terminator on the next line*/

ALGOL 60

'COMMENT' this is a first comment;'COMMENT' ****** this is a second comment ******;

ALGOL 68

With Standard

With Extensions

ALGOL-M

begincomment - This form is borrowed from ALGOL 60;% And this is borrowed from ALGOL W %% ALGOL-M will not compile an "empty" program, so we have %% to include at least one code-generating statement!      %write("This is only an exercise");end

ALGOL W

begin    comment a comment;    % another comment    ;    % and      another    %end this_word_is_also_a_comment.

AmigaE

/* multiline commentare like C ... */-> this is a end of line comment

AngelScript

// This is a comment

AntLang

2 + 2 /This is a comment

Apex

System.debug ('I will execute');   // This comment is ignored./* I am a large comment, completely ignored as well.*/

APL

⍝ This is a comment

AppleScript

--This is a single line commentdisplay dialog"ok"--it can go at the end of a line# Hash style comments are also supported(* This is a multiline comment*)(* This is a comment. --comments can be nested  (* Nested block comment *)*)

display dialog"ok"#Starting in version 2.0, end-line comments can begin with a hash

Arendelle

ArkScript

# this is a comment# another comment# with another below

ARM Assembly

/* ARM assembly Raspberry PI comment one line *//*  comment line 1    comment line 2*/ mov r0,#0    @ this comment on end of linemov r1,#0    //  authorized comment

Arturo

; This is a simple single-line commenta:10; another single-line comment; Now, this is a; multi-line comment

Asymptote

// double slash to newline

AutoHotkey

Msgbox,commentsdemo ; end of line comment/*multiline comment1multiline comment2*/

AutoIt

#csEverything between the cs and and the ce is commented.Commented code is not used by the computer.#ce;individual lines after a semicolon are commented.

AWK

BEGIN{# this code does something# do something}

Axe

.This is a single-line comment

...This is a multi-line comment...

...If 0This is a comment only if the condition evaluates to zero...

...!If 1This is a comment only if the condition evaluates to nonzero...

...ElseThis is a comment only if the previous conditional comment was executed (and vice versa)...

Babel

-- This is a line-comment#    This is a block-comment    It goes until de-dentdedent: 0x42 -- The comment block above is now closed

Ballerina

// This is a single-line commentintx=10;// This is an inline comment#Representsauserrecord.typeUserrecord{#User'sID.intid;#User'sname.stringname;};

BASIC

100REM Standard BASIC comments begin with "REM" (remark) and extend to the end of the line110PRINT"this is code":REMcommentafterstatement

'this is a commentPRINT"this is code"'comment after statement

Applesoft BASIC

REM COMMENT AFTER THE REM KEYWORD

0REMLEAVETHESPACEOUTAFTERTHEREMWHENTYPINGORPASTING

10PRINT"THIS IS CODE":REM:PRINT"THIS IS CODE"

20GOSUB110COMMENT:PRINT"THIS IS CODE"

30GOTO40"COMMENT:THISISACOMMENT

::::::::::::::::::::::::::::::::::::::40REM50:60REM<ctrl>+J70FORI=1to1080::::PRINTI;MID$("THIS IS A COMMENT",1,0)90NEXT

100END:THISISACOMMENT

110RETURN:"COMMENTFORANDATTHEEND

BaCon

BASIC256

rem this is a comment# and this is tooprint "this is code"  #comment after statement

Chipmunk Basic

10remthisisacomment20' and this is too30print"this is code":'comment after statement40print"and more code":remcommentafterstatement

IS-BASIC

100 REM Standard BASIC comments begin with "REM" (remark) and extend to the end of the line110 PRINT "this is code" ! comment after statement

Minimal BASIC

10REM STANDARD BASIC COMMENTS BEGIN WITH "REM" AND EXTEND TO THE END OF LINE20END

MSX Basic

10remthisisacomment20' and this is too30print"this is code":'[:] it's optional40print"and more code":remcommentafterstatement

Quite BASIC

10remthisisacomment20print"this is code":remcommentafterstatement

True BASIC

!thisisacommentPRINT"this is code"!commentafterstatement

XBasic

PROGRAM"Comments"VERSION"0.0000"DECLAREFUNCTIONEntry()FUNCTIONEntry()'this is a commentPRINT"this is code"'comment after statementENDFUNCTIONENDPROGRAM

Yabasic

rem  Hey, this is a comment#    the hash-sign too (at beginning of line)// even the double slash' and the single quote (at beginning of line)print "Not a comment" #    This is an error !!print "Not a comment"://   But this is again a valid commentprint "Not a comment" //   even this.print "Not a comment" rem  and this !

Batch File

rem Single-line comment.

:: Another option, though undocumented and known:: to fail in some cases. Best avoided.

% this works as long as you have no variable named exactly like this sentence. %

BBC BASIC

REM This is a comment which is ignored by the compiler*|Thisisacommentwhichiscompiledbutignoredatruntime

bc

/* This is a comment. */2+/* Comment between tokens. */3"This is a string, /* NOT a comment */."/* * A comment can have multiple lines. These asterisks in the middle * of the comment are only for style. You must not nest a comment * inside another comment; the first asterisk-slash ends the comment. */

#!/usr/bin/bc# This form of comment is an extension, not part of standard bc.# Your program must not have a #! shebang line# unless your bc supports this form of comment.2+3  # It can be after a statement.a=1  # The newline is not part of the comment.b=2  # So this line is a different statement.

Beef

//This is a comment.//This is another comment./* This is also a comment. *//* This is amulti-linecomment */

static{/// Must be placed directly above the method, including attributes./// Using multiple lines like this is also fine. Both will be recognized.[Optimize]publicstaticvoidDoAThing(){}/// Documentation also works for types.structSomeStruct{/**        * Multiline comment with two ** at the start works in the same way.        */voidPrivateMethod(){}}/**    * If you have a really long explainer here, you may not actually want to show that in autcompletion prompts.    * @brief Allows you to select only this line to be shown.    *    * @param a This is shown when writing a call to this function and placing parameter "a".    * @param b For the second argument, the documentation for b (this!) will show up instead.    */publicstaticvoidDoAnotherThing(inta,intb){}}

Befunge

&readanumber2+addtwo.@displayresultandexit^-inlinecomments-^<-^-othercomments

&;readanumber;2+;addtwo;.@;displayresultandexit;^-inlinecomments-^<-^-othercomments;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;completelyisolatedcommentblockfortheparanoid;;(almost-youcanstillskipintoit.);;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

Binary Lambda Calculus

Blast

# A hash symbol at the beginning of a line marks the line as a comment

BQN

# This is a comment

Bracmat

Brainf***

This is a comment

Brat

# Single line comment#* Multi   Line   Comment *#

Bruijn

# This is a comment

Brlcad

 # Comments in mget scripts are prefixed with a hash symbol ls   # comments may appear at the end of a line

Burlesque

"I'm sort of a comment"vv

"I'm avery long comment spanningover several lines"vv

C

/* This is a comment. *//* So is this   multiline comment. */

structcharisma{};voidf(char/* comment */isma){}

/* some comment /* trying to nest some other comment */inside*/

#if 0While technically not a comment, this is also ignored by the compiler#endif

#ifdef UNDEFINEDThisisnotcompiled.#if 0Nor is this.#endifAndthisstillisnotcompiled.#endif

#if 0This isn't valid.#endif

// C++ single-line comments were adopted in the C99 standard.

C#

//This is a comment.//This is other comment./* This is a comment too. *//* This is amulti-linecomment */

C++

// This is a comment

// This is a valid comment // with a "nested" comment

#define FOO \  (macro text)// comment(nomoremacrotext)

Chapel

// single line/* multiline */

Chef

Comment Stew.This is a comment.The other comment is a loop, but you can name it anything (single word only).You can also name ingredients as commentsThis is pseudocode.Ingredients.Ingredient listMethod.Methods.SingleWordCommentOne the Ingredient.Methods.SingleWordCommentTwo until SingleWordCommentOned.Methods.

ChucK

<-- Not common // Usual comment

Clean

Start=/* This is a multi-           line comment     */17// This is a single-line comment

Start=/* This is a comment /* Nested comment */ still a comment */17

Clojure

;; This is a comment(defnfoo[]123); also a comment

(comment(println(foo))"bar":baz123(System/exit0));; does nothing, returns nil

(+1(comment"foo")3);; Throws an exception, because it tries to add nil to an integer(+1#_"foo"3);; Returns 4

CMake

# A single-line comment

#[[A multi-line   comment ]]#[==[A multi-line comment     with [[nested brackets]]. ]==]

COBOL

Fixed format

      * an asterisk in 7th column comments the line out

DDISPLAY"Debug"

Free format

*> Thiscommentsyntaxwasdefined(withfreeformatcode)inCOBOL2002.

>>D DISPLAY"Debug"

NOTE statement

NOTEthisparagraphiscommentedoutandignored.

REMARKS and other statements

IDENTIFICATIONDIVISION.PROGRAM-ID.program.AUTHOR.Restoflineignored.REMARKS.Restoflineignored.REMARKS.Moreremarks.SECURITY.lineignored.INSTALLATION.lineignored.DATE-WRITTEN.same,humanreadabledatesareallowedforinstanceDATE-COMPILED.same.DATE-MODIFIED.thisoneishandywhenauto-stampedbyaneditor.

CoffeeScript

# one line comment### multilinecomment ###

ColdFusion

As ColdFusion's grammar is based around HTML syntax, commenting is similar to HTML.<!--- This is a comment.  Nothing in this tag can be seen by the end user.       Note the three-or-greater dashes to open and close the tag. ---><!--  This is an HTML comment.  Any HTML between the opening and closing of the tag will be ignored, but any ColdFusion code will still run.       Note that in the popular FuseBox framework for ColdFusion, the circuit.xml files require that you use this style of comment. -->

/* This is a comment */// This is also a comment

Common Lisp

;;;; This code implements the foo and bar functions;;; The foo function calls bar on the first argument and multiplies the result by the second.;;; The arguments are two integers(defunfoo(ab);; Call bar and multiply(*(bara); Calling barb));;; The bar function simply adds 3 to the argument(defunbar(n)(+n3))

(defunbar(n)"Add 3 to the argument."(+n3))(defclassbutton(widget)(labelaction)(:documentation"This is a push-button widget."))

Component Pascal

(* Comments (* can nest *)andtheycanspanmultiplelines.*)

Crystal

# currently, Crystal only supports single-line comments# This is a doc comment. Any line *directly* above (no blank lines) a module, class, or method is considered a doc comment# Doc comments are used to generate documentation with `crystal docs`classFooend

D

voidmain(){// A single line comment./* This is a simple C-style comment that can't be nested.    Comments mostly work similar to C, newlines are irrelevant.    *//+ This is a nestable comment      /+ See?      +/    +//// Documentation single line comment./**    Simple C-style documentation comment.    *//++    Nestable documenttion comment.    +/}

Dart

// This is a single line comment, which lasts until the end of the line. The Dart linter prefers this one./* This is also a valid single line comment. Unlike the first one, this one terminates after one of these -> *//*  You can use the syntax above to make multi line comments as well.  Like this!*//// These are doc comments. You can use dartdoc to generate doc pages for your classes with these.////// Formatting [variable] and [function] names like so allows dartdoc to link to the documentation for those entities.

dc

[Making and discarding a string acts like a comment] sz

# remainder of line is a comment

Delphi

// single line comment

Deluge

// single line comment

DuckDB

Dragon

// This is a comment

/*  This is  a multiple  line comment. */

showln "Hello " /* This is an inline comment */ "world"

Dragonstone

#[    Multi-Line Comment.]##[    Nested Multi-Line Comment.    #[        Inner comment.        #[            It can go deep.        ]#    ]#    Outer comment.]## Single Line Comment#[ Multi-Line Comment on line ]# message = "Hello!" #[ Inside or Outside ]#echo message  # Another Trailing Comment.

DWScript

(* This is a comment.   It may extend across multiple lines. *){ Alternatively curly braces  can be used. }/*C-stylemulti-linecommentsaresupported*/// and single-line C++ style comments too

Dyalect

/* This is amulti-line comment *///This is a single-line comment

Dylan

// This is a comment/*   This is a comment   that spans multiple   lines*/

Déjà Vu

#this is a comment!print "this is not a comment, obviously" #this is a comment as well

E

# This is a regular comment.? "This is an Updoc comment, which> is an executable example or test case.".split(" ")# value: ["This", "is", "an", "Updoc", "comment,", "which#        is", "an", "executable", "example", "or", "test", "case."]

EasyLang

# This is a comment

EchoLisp

666; this is an end-of-line comment#| This is a multi-line comment Nesting is not allowed|#;; The (info <name> [<string>)] function associates a symbol and a comment;; These info strings are saved in permanent memory (local storage);; Unicode characters may be used, as everywhere in the language(definemynumber666)→mynumber(info'mynumber"👀 Symbols may be commented with an information string 👺")(info'mynumber)→displaystheaboveinsidethe'info'field.

ECL

// this is a one-line comment

/* this is a block comment - the terminator can be on the same lineor any succeeding line – everything in between is ignored */

Ecstasy

/* * This is a multi-line comment. */Inti=0;// This is an end-of-line comment

ed

# A single-line comment.# The only type of comment, really.# No block comments in ed

EDSAC order code

[This is a comment][And soisthis][But in 1949 they wouldn't have been]

EGL

Eiffel

-- inline comment, continues until new line

Ela

//single line comment/*multiple linecomment*/

Elena

//single line comment/*multiple linecomment*/

Elixir

# single line comment

Elm

-- a single line comment{- a multiline comment   {- can be nested -}-}

Emacs Lisp

; This is a comment

"This is effectively a comment,if used at a place where the result is ignored"

(defunsubtract-second-from-first(xy)"This function subtracts its second argument from its first argument."(-yx))

EMal

# This is a line comment.^|This is a single line block comment.|^^| This is | a multi-line | block comment. |^^|This is a ^|nested|^ block comment.|^

Erlang

% Erlang comments begin with "%" and extend to the end of the line.

ERRE

! Standard ERRE comments begin with ! and extend to the end of the linePRINT("this is code") ! comment after statement

Euphoria

-- This is a comment

/*This is a comment*/

F#

// this comments to the end of the line(* this comments a region   which can be multi-line *)

Factor

! Comments starts with "! "#! Or with "#! "! and last until the end of the lineUSE:multiline/* The multiline vocabulary implements   C-like multiline comments. */

Falcon

/* Start comment block My Life Story */// set up my bank account totalbank_account_total = 1000000 // Wish this was the case

FALSE

{comments are in curly braces}

Fancy

# Comments starts with "#"# and last until the end of the line

Fennel

; This is a single-line comment

Fermat

Function Foo(n) =     {Comments within a function are enclosed within curly brackets.}    {You can make multi-line comments        such as this one.}    n:=n^2 + 3n - 222;   {Comments can go after a semicolon.}    n:=n+1;    n.; comments between functions are preceded by semicolons, like thisFunction Bar(n) =    2n-1.

Fish

v This is the Fish version of the Integer sequence task>0>:n1+v all comments here^o" "< still hereAnd of course here :)

Forth

\ The backslash skips everything else on the line( The left paren skips everything up to the next right paren on the same line)

:myword( a b -- c )...

:add'em( a b -- a+b )+;:strlen( addr -- len )countnip;

\s skips all remaining text in the file(( skips until the next double-paren,    stretching across multiple lines ))comment:   Ignore all text in this sectioncomment;doc   Another comment blockenddoc/* C-style comment */(* Pascal-style comment *)

Fortran

C     This would be some kind of commentC     Usually one would avoid columns 2-6 even in a comment.

C     If compiled in debugging mode, print the current value of ID     PRINT *, I

real :: a = 0.0   ! initialize A to be zero

?? if (.false.) thendo while (oh_no)   a = bad_news()   b = big_mistake()   c = gigo()end do?? end if

FreeBASIC

' FB 1.05.0 Win64' This a single line commentREM This is another way of writing a single line comment/'   This is a  multi-line  comment'//'   Multi-line comments  /'    can also be nested  '/  like this'/

Frink

// This is a single-line comment/*  This is a comment    that spans multiple lines    and so on.*/

Futhark

-- Single-line comment-- Multi-line-- comment (yes, just several single-line comments).

FutureBasic

//  Single line commentrem Single line comment/*  Single line comment  *//*  Multiline  comment*/

FUZE BASIC

//Comment (No space required)# Comment (Space required)REM Comment (Space require)PRINT "This is an inline comment."//Comment (No space required)END

Gambas

 ' This whole line is a comment and is ignored by the gambas interpreter print "Hello" ' Comments after an apostrophe are ignored '' A bold-style comment ' TODO:  To Do  comment will appear in Task Bar ' FIXME: Fix Me comment will appear in Task Bar ' NOTE:  Note   commnet will appear in Task Bar

GAP

# Comment (till end of line)

gecho

( this is a test comment... o.O ) 1 2 + .

Gema

! comment starts with "!" and continues to end of line

Genie

// Comment continues until end of line/* Comment lasts between delimiters */

GML

 // comment starts with "//" and continues to the end of the line

 /* a multi-line comment starts with slash-asterisk and,ends with asterisk-slash.also note: * A multi-line comment is ignored inside a string * A multi-line comment can be ended inside a line*/

gnuplot

# this is a comment# backslash continues \a comment to the next \line or lines

# this doesn't workfoo(n) = (n                \          + 2    # no good \          + 3)          # behaves as if you wrote merelyfoo(n) = (n+2

Go

// this is a single line comment/* this is   a multi-line   block comment./* It does not nest */

Golfscript

# end of line comment

Gri

# this is a commentshow 123        # this too is a comment

// this is a commentshow 123        // this too is a comment

Groovy

GW-BASIC

100 REM Standard BASIC comments begin with "REM" (remark) and extend to the end of the line110 PRINT "this is code": REM comment after statement

Haskell

i code = True -- I am a comment.{- I am also   a comment. {-comments can be nested-}   let u x = x x (this code not compiled)   Are you? -}-- |This is a Haddock documentation comment for the following codei code = True-- ^This is a Haddock documentation comment for the preceding code{-|  This is a Haddock documentation block comment-}i code = True

Haxe

// Single line commment./*    Multiple   line   comment.*/

HicEst

! a comment starts with a "!" and ends at the end of the line

Hope

! All Hope comments begin with "!" and extend to the end of the line

HTML

<!-- Anything within these bracket tags is commented, single or multi-line. -->

Icon andUnicon

# This is a commentprocedure x(y,z)    #: This is a comment and an IPL meta-comment for a procedure

IDL

; The following computes the factorial of a number "n"fact = product(indgen( n )+1) ; where n should be an integer

Idris

(according to Gemini AI):Idris2 uses comment characters similar to Haskell:Single-line comments: Start with -- (two hyphens). Everything from -- to the end of the line is a comment.Multi-line comments: Enclosed by {- and -}. These can span multiple lines and can also be nested.Additionally, Idris2 supports inline documentation comments which begin with ||| (three pipe symbols). These are parsed by the compiler and can be used to generate documentation.

Inform 7

[This is a single-line comment.][This is amulti-line comment.][Comments can [be nested].]

Insitux

;this is a comment; and using semicolons here is fine(+ 2 2) ;this is a comment"this string will be ignored if in the top scopewhich can also stretch acrossmultiple lines"(do "if you're desperate, using do will make sure this string will not be returned also"  (+ 2 2))

Intercal

PLEASE NOTE This is a comment

Io

# Single-line comment// Single-line comment/* Multi-line   comment */

Isabelle

theory Textimports Mainbegin(* Top-level Isar comment. *)end

J

NB. Text that follows 'NB.' has no effect on execution.'Character strings in J may have their value be ignored and treated as comment text.'0 : 0Multi-line comments may be placed in strings,like this.)Note 'example'Another way to record multi-line comments as text is to use 'Note', which is actuallya simple program that makes it clearer when defined text is used only to provide comment.){{)n  J release 9's nestable blocks can be used as comments.  Typically, this would be in contexts where the blocks would not be used.  That said, "literate coding practices" may stretch the boundaries here.  Also, noun blocks (beginning with ')n') avoid syntactic concerns about content.  These blocks even allow contained '}}' sequences to be ignored (unless, of  course the }} character pair appears at the beginning of a line).}}

Janet

(according to Gemini AI):The Janet programming language uses the # character for comments.Single-line comments: Everything from # to the end of the line is treated as a comment.Janet does not have built-in multi-line comments in the same way some other languages do (like {- ... -} in Idris2 or /* ... */ in C-like languages). However, because Janet is expression-oriented, you can often use multi-line strings as a form of "comment" if you put them in a context where their value isn't used.

Java

C Style

/* This is a comment */

/* * This is * a multiple * line comment. */

C++ Style (inline)

// This is a comment

Java Documentation (Javadoc)

/** This is a Javadoc comment */

/** * This is * a multiple * line Javadoc comment */

Sneaky

public class JustComments {    /*    \u002A\u002F\u0070\u0075\u0062\u006C\u0069\u0063\u0020\u0073\u0074\u0061\u0074\u0069\u0063    \u0020\u0076\u006F\u0069\u0064\u0020\u006D\u0061\u0069\u006E\u0028    \u0053\u0074\u0072\u0069\u006E\u0067\u005B\u005D\u0061\u0072\u0067\u0073\u0029    \u007B\u0053\u0079\u0073\u0074\u0065\u006D\u002E\u006F\u0075\u0074\u002E    \u0070\u0072\u0069\u006E\u0074\u006C\u006E\u0028\u0022\u0048\u0065\u006C\u006C\u006F\u0022    \u002B\u0022\u0020\u0057\u006F\u0072\u006C\u0064\u0021\u0022\u0029\u003B\u007D\u002F\u002A    */}

JavaScript

n = n + 1; // This is a comment

// This is a valid comment // with a "nested" comment

/* This isa multi linecomment// with a "nested" commentand another line in the comment*/

JCL

//* This is a comment line (//* in columns 1-3)

/* This is also a comment line (/*  in columns 1-3)

Joy

# this is a single line comment(* this is amulti-line comment *)

jq

# this is a single line comment"Hello #world" # the first # on this line is part of the jq program

Jsish

#!/usr/bin/env/jsish/* Comments, in Jsish */// to end of line comment, double slash/* Enclosed comment, slash star, ending with star slash Cannot be nested, but can cross line boundaries and occur pretty much anywhere whitespace is allowed*/var x = 'X'; /* A var called X *//* active code on this line */ printf("Result %q %d\n", /* comment code mix */ x, /**/42);;x;// jsish also handles double slash commented// unit test echo lines as a special case of "expect failure";//noname(x);/*=!EXPECTSTART!=Result X 42x ==> Xnoname(x) ==>PASS!: err = can not execute expression: 'noname' not a function=!EXPECTEND!=*/

Output:

Julia

# single line#=Multi-linecomment=#

K

  / this is a comment  2+2  / as is this

KonsolScript

//This is a comment.//This is another comment./* This is a comment too. *//* This is a multi-linecomment */

Kotlin

// This is a single line comment/*    This is a     multi-line    comment*//*    Multi-line comments    /*        can also be nested    */    like so*/const val CURRENT_VERSION = "1.0.5-2"  // A comment can also be added at the end of a lineconst val /* or even in the middle of a line */ NEXT_MAJOR_VERSION = "1.1"/** * This is a documentation comment used by KDoc. * * It's documenting the main function which is the entry-point to a Kotlin executable. * * @param [args] A string array containing the command line arguments (if any) passed to the executable * @return Implicit return value is Unit which signifies no meaningful return value (like 'void' in java) */fun main(args: Array<String>) {    println("Current stable version is $CURRENT_VERSION")    println("Next major version is $NEXT_MAJOR_VERSION")}

Lambdatalk

Out of bracketed expressions words are ignored by the lambdatalk evaluator and are dislayed as they are:Hello World-> Hello WorldIn order to prevent any evaluation and display of some parts of code put them inside triple degrees "°°°": °°°this is   a comment ... and an expression {+ 1 2}     on several lines°°°

LabVIEW

Lang

# This is a comment

# This is a comment\with multiple lines

# {{{This is a commentwhich has more than2 linesand this one}}}

Lang5

# This is a comment.

langur

# single line comment starts with hash mark/* inline or multi-line comment uses C-style syntax */

Lasso

//This is a comment./* This is also a comment. *//* A multi-linecomment *//* ==========================A multi-linecomment =========================== */

LaTeX

\documentclass{minimal}\begin{document}% This is a comment\end{document}

\documentclass{minimal}\newcommand{\firstpart}[1]{under#1}\newcommand{\secondpart}{able}\newcommand{\complete}{%\firstpart{stand}%\secondpart}\begin{document}\complete\end{document}

Liberty BASIC

'This is a commentREM This is a commentprint "This has a comment on the end of the line." 'This is a commentprint "This also has a comment on the end of the line." : REM This is a comment

Lily

# This is a single-line comment

#[ Thisisablockcomment ]#

LilyPond

% This is a comment%{ This is a commentspanning several lines %}

Lingo

-- This is a comment.-- This is another comment

LiveCode

-- comment may appear anywhere on line// comment may appear anywhere on line# comment may appear anywhere on line/*  this is a block comment thatmay span any number of lines */

Logo

; comments come after a semicolon, and last until the end of the line

Logtalk

% single-line comment; extends to the end of the line

/* multi-linecomment */

LOLCODE

OBTW This is amulti line commentTLDR

BTW This is a single line comment.

LotusScript

' This is a comment

%REMThis is a multi- line comment.%END REM

LSE

* Ceci est un commentaire qui prend fin quand la ligne se termine(* Ceci est un commentaire sur plusieurs lignescomme vous pouvez le voir puisqu'il s'étend surplusieurs lignes justement... *)(* Cette exemple est selon la revision LSE-2000 *)

LSE64

# single line comment (space after # is required)

# arg1 arg2 '''yields''' result|''nothing''

Lua

-- A single line comment--[[A multi-line     comment --]]

--[====[ A multi-line comment that can contain [[ many square brackets ]]]====]

M2000 Interpreter

Module Comments {Rem {Print "no print here"? "no print here either"}Rem : single line remark// single line\ single line' single line? "ok" : Rem : Print "not print - but code have syntax highlight" ? "ok" // single line - start without double colon? "ok" \ single line - start without double colonPrint "ok" ' single line}Comments

M4

eval(2*3)  # eval(2*3)  "#" and text after it aren't processed but passed alongdnl  this text completely disappears, including the new linedivert(-1)Everything diverted to -1 is processed but the output is discarded.A comment could take this form as long as no macro names are used.divert

Output:

some text`'dnl then a deleted comment

changecom(%)% now percent prevents macro expansion

changecom()GNU m4 now no macro expansion suppression character at all

changecom(/*,*/)/* GNU m4 now no macro expansion in C style comments */

Maple

x := 4: x; # Everything on this line, after this, is a comment.17; (* This   is   a multiline comment *) 23.4;

Output:

Mathematica /Wolfram Language

(*this is a comment*)

If[a(*number 1*)<(* is smaller than number 2*) b, True (*return value (*bool true*)*), False (*return bool false*)]

If[a < b, True, False]

MATLAB

%This is a comment%% Two percent signs and a space are called a cell divider

Maxima

/* Comment  /* Nested comment */*/

MAXScript

-- Two dashes precede a single line comment/* This is a   multi-line comment */

MBS

! A pling in a line starts a commentINT   n:=5   ! Comments can appear at the end of a line/* A comment block can also be defined using climbstar and starclimb symbols.   This allows comments to be stretched across several lines */

MEL

// This is a single line comment

Metafont

% this is "to-end-of-line" comment

Microsoft Small Basic

' This is a commenti = i + 1  ' You can also append comments to statements

min

; this is a comment1 1 + ; add one and one together

MiniScript

// How many roads must a man walk down?x =  6 * 7  // forty-two

Mirah

puts 'code' # I am a comment/* This is * a multiple * line comment */

MIPS Assembly

;this is a commentli $t0,0x1234     ;this is also a comment

# this is a commentli $t0,0x1234     # this is also a comment

mIRC Scripting Language

;Single Line Comment/*MultipleLineComment*/

Modula-2 /Modula-3

(* Modula-2/Modula-3 use the same style of comments *)(* ...and comments (* can nest *)   and they can span multiple lines. *)

Monte

# This comment goes to the end of the line/** This comment is multi-line.    Yes, it starts with a two stars    and ends with only one.    These should only be used for docstrings. */

MontiLang

/# This is a comment #//# comments can span multiple lines nested comments are not supported #/

MOO

"String literals are technically the only long-term comment format";// Some compilers will, however, compile // one-liners to string literals as well (and vice-versa)/* Classical C-style comments are removed entirely during compile */

Nanoquery

// this is a comment// this is also a comment

NATURAL

* This is a comment and extends to the end of the line

Neko

// Single line comment, of course!/*Multi line comment!*//**Documentation block<doc>can include XML parsed nodes between doc tags</doc>**/

Nemerle

// This comment goes up to the end of the line/* Thisisamultilinecomment */

NESL

% This is a comment. %

NetRexx

/* NetRexx comment block*/-- NetRexx line comment

NewLISP

; This is a comment

Nim

# Nim supports single-line commentsvar x = 0 ## Documentation comments start with double hash characters.var y = 0 ## Documentation comments are a proper part of the syntax (they're not discarded by parser, and a real part of AST).#[There are also multi-line commentsEverything inside of #[]# is commented.]## You can also discard multiline statements:discard """This can be considered as a "comment" tooThis is multi-line"""

Nix

# This comment goes up to the end of the line/* Thisisamultilinecomment */

NSIS

# This is a comment that goes from the # to the end of the line.; This is a comment that goes from the ; to the end of the  /* This is a multi-linecomment */

Oberon-2 /Oberon-07

(* Oberon-07/Oberon-2 use the same style of comments as Modula-2: this is a comment *)(*    and this is a   multiline comment   (* with a nested comment *)*)

Objeck

#This is a comment.# This is other comment. #~ This is a comment too. ~# #~ This is a multi-linecomment ~#

Objective-C

OCaml

(* This a comment   (* containing nested comment *) *)(** This an OCamldoc documentation comment *)

Octave

# I am a comment till the end of line% I am a comment till the end of line%{  This comment spans  multiple lines%}

Odin

(According to Gemini AI):The Odin programming language supports two types of comment characters:Single-line comments: Begin with //.Code snippet// This is a single-line commentmy_variable: int // A comment for documentationMulti-line comments: Begin with /* and end with */. Multi-line comments can also be nested.Code snippet/*This is a multi-line comment./* NOTE: comments can be nested! */You can have any text or code here and have it be commented.*/

Oforth

// This is a comment...

ooRexx

/*  Multi-line comment block */-- this type of comment works in ooRexx, NetRexx and some of the more popular REXX implementations like Reginahour = 0  -- which is, like midnight, dude.hour = 12 /* time for lunch! works as well (and really everywhere) */

Openscad

// This is a single line comment/*  This comment spans  multiple lines*/

OPL

REM This is a comment.PAUSE 20 REM Can be placed behind statements, too.

OxygenBasic

'  Basic line comment;  Assembly code line comment// C line comment/* C block comment */

Oz

% one line comment%% often with double "%" because then the indentation is correct in Emacs/* multi line   comment*/

PARI/GP

Pascal

(* This is a comment.   It may extend across multiple lines. *){ Alternatively curly braces  can be used. }(* This is a valid comment in Standard Pascal,   but not valid in [[Turbo Pascal]]. }{ The same is true in this case *)

PascalABC.NET

(* This is a    multiline comment *){ This is also a    multiline comment }//  This is a single line comment

PASM

# This is a commentprint "Hello\n"    # This is also a commentend

Peloton

<@ OMT>This is amultilinecomment</@>

Perl

# this is commented

my $var = 1; # this is the comment part

=podHere are my commentsthis is multi-line=cut

=head1=head4=over 4=Any Old String

Phix

Output:

PHP

# this is commented// this is commented

$var = 1; # this is the comment part$var = 1; // this is the comment part

/*Here are my commentsthis is multi-line*/

/** * phpdoc Comments * @todo this is a todo stub */

Picat

/* * Multi-line comment */% Single-line Prolog-style comment

PicoLisp

# The rest of the line is ignored#{   This is a   multiline comment}#NILImmediately stop reading this file. Because all text in the input file followinga top-level 'NIL' is ignored.This is typically used conditionally, with a read-macro expression like`*Dbgso that this text is only read if in debugging mode.

Pike

// This is a comment./* This is a    multi   line   comment */int e = 3; // end-of-statement comment.

PL/I

/* This is a comment. */

/* This is a multiline comment. */

PL/SQL

--this is a single line comment

/*this is a multilinecomment*/

v_var number; --this is an end of line comment

Plain English

\A comment like this lasts until the end of the linePut 1 plus [there are inline comments too] 1 into a number.

PlainTeX

% this is a commentThis is not.

\def\firstpart#1{under#1}\def\secondpart{able}\def\complete{\firstpart{stand}%\secondpart}\complete

Pluto

-- Single line comment--[[ Multi-line  comment ]]--[===[  Another syntax  [[ which may contain square brackets ]]]===]

Pop11

;;; This is a comment

/* First line   Second line */

/* This is a comment /* containing nested comment */ */

#_IF falsesome code #_ENDIF

#_IF falseThis w'ont work#_ENDIF

PostScript

%This is a legal comment in PostScript

PowerShell

# single-line comment

<# multi-line   comment #>

Processing

// a single-line comment/* a multi-line   comment*//* * a multi-line comment * with some decorative stars */// comment out a code line// println("foo"); // comment at the end of a lineprintln("foo bar"); // "baz"

Processing Python mode

# a single-line comment """Not strictly a comment, bare multi-line strings are usedin Python as multi-line comments. They are also used asdocumentation strings or 'docstrings' when placed as thefirst element inside function or class definitions.""" # comment out a code line# println("foo")# comment at the end of a lineprintln("foo bar") # "baz"# there is no way to make an inline comment

ProDOS

IGNORELINE your text here

ProgressBASIC

Prolog

% this is a single-line comment that extends to the end of the line

/* This is amulti-line comment */

PureBasic

;comments come after an unquoted semicolon and last until the end of the linefoo = 5 ;This is a commentc$ = ";This is not a comment"  ;This is also a comment

Python

# This is a commentfoo = 5 # You can also append comments to statements

"""Un-assigned strings in triple-quotes might be used    as multi-line comments"""'''   "triple quoted strings" can be delimited by either 'single' or "double" quote marks; and they can contain mixtures   of other quote marks without any need to \escape\ them using any special characters.  They also may span multiple   lines without special escape characters.'''

Documentation Strings

#!/usr/bin/env python# Example of using doc strings"""My Doc-string example""" class Foo:     '''Some documentation for the Foo class'''     def __init__(self):        "Foo's initialization method's documentation" def bar():    """documentation for the bar function""" if __name__ == "__main__":    print (__doc__)    print (Foo.__doc__)    print (Foo.__init__.__doc__)    print (bar.__doc__)

Quackery

 ( The word "(" is a compiler directive (a builder,   in Quackery jargon) that causes the compiler to    disregard everything until it encounters a ")"   preceded by whitespace.     If you require more than that, it is trivial to   define new comment builders...                  )   [ behead carriage = until ] builds #   # Now the word "#" will cause the compiler to  # disregard everything from the "#" to the end of   # the line that it occurs on.   [ drop $ "" ] builds commentary   commentary     The word "commentary" will cause the compiler to  disregard everything that comes after it to the   end of the source string or file.

QB64

REM This is a remark...' This is also a remark...IF a = 0 THEN REM (REM follows syntax rules)IF a = 0 THEN '(apostrophe doesn't follow syntax rules, so use END IF after this)END IF'Metacommands such as $DYNAMIC and $INCLUDE use the REM (or apostrophe).REM $STATIC 'arrays cannot be resized once dimensioned.REM $DYNAMIC 'enables resizing of array dimensions with REDIM.REM $INCLUDE: 'loads a reference file or library.

R

# end of line comment

Racket

; this is a to-end-of-line coment#| balanced comment, #| can be nested |# |##;(this expression is ignored)#; ; the following expression is commented because of the #; in the beginning(ignored)

Raku

# the answer to everythingmy $x = 42;

#`(     Comments beginning with a backtick and one or more opening bracketing characters are embedded comments.    They can span more than one line…)my $y = #`{ …or only part of a line. } 3;

for #`(each element in) my @array {    say #`(or print element) $_ #`(with a newline);}

#`{{  This close curly brace } won't terminate the comment early.}}

=begin commentPod is the successor to Perl 5's POD. This is the simplest way to use it for multi-line comments.For more about Pod, see Pod: https://docs.perl6.org/language/pod=end comment

#| Compute the distance between two points in the plane.sub distance(    Rat \x1, #= First point's abscissa,    Rat \y1, #= First point's ordinate,     Rat \x2, #= Second point's abscissa,     Rat \y2, #= Second point's ordinate, ){    return sqrt((x2 - x1)**2 + (y2 - y1)**2)}

Rapira

\ This is a Rapira comment.

Raven

 # this is a comment

Rebol

; This is a line comment.{ Multi-line strings can  be used as comments   if you like }

plus2: func [    "Adds two to a number."    n [number!] "The number to increase."][    n + 2]

Relation

// This is a valid comment // A space is needed after the double slash

Retro

( comments are placed between parentheses. A space must follow the opening parenthesis. )

REXX

/*REXX program that demonstrates what happens when dividing by zero.  */y=7say 44 / (7-y)      /* divide by some strange thingy.*/

/*REXX program to demonstrate various uses and types of comments. *//* everything between a "climbstar" and a "starclimb" (exclusive of literals) is   a comment.                          climbstar =  /*   [slash-asterisk]                               starclimb =  */   [asterisk-slash]            /* this is a nested comment, by gum! */            /*so is this*/Also, REXX comments can span multiple records.There can be no intervening character between the slash and asterisk  (orthe asterisk and slash).  These two joined characters cannot be separatedvia a continued line, as in the manner of:       say 'If I were two─faced,' ,           'would I be wearing this one?' ,           '      --- Abraham Lincoln' Here comes the thingy that ends this REXX comment. ───┐                                                       │                                                       │                                                       ↓                                                       */    hour = 12       /*high noon                   */midnight = 00       /*first hour of the day       */   suits = 1234     /*card suits:   ♥  ♦  ♣  ♠    */ hutchHdr = '/*'  hutchEnd = "*/"    /* the previous two "hutch" assignments aren't        the start  nor  the end of a REXX comment. */  x=1000000 **   /*¡big power!*/   1000/*not a real good place for a comment (above),   but essentially, a REXX comment can be   anywhere whitespace is allowed.            */

-- A REXX line comment (maybe)say "something" -- another line comment (maybe)

Ring

//this is a single line comment#this also a single line comment!

/*This is a multi-linecomment that will be completelyignored by the compiler/interpreter*/

RLaB

x = "code" # I am a commentx = "code" // Here I comment thee#  matlab-like document line// C++ like document line

Robotic

. "This is a comment line". "Print Hello world"* "Hello world.". "This is the only way to comment a line in Robotic"

. "@NewRobotName"

Rockstar

Rockstar is cool.(Rockstars don't like comments, but if you really really want to, you write them in parentheses and they are believed to be multiline. In fact, parentheses are just the comment symbols, so you can't even use parentheses in math, so if you want the addition to happen before the multiplication, do the addition and assign it to a variable. And by the way, the Rockstar is cool line assigned the number 4 to the variable Rockstar, because cool is four letters and all that. And this comment has gone on way too long for a language with a developer community that hates comments.)Shout Rockstar.(Might as well put that number 4 on the screen.)

RPL

RTL/2

Ruby

x = "code" # I am a comment=begin helloI a POD documentation comment like Perl=end puts "code"

Run BASIC

'This is a commentREM This is a comment print "Notice comment at  the end of the line."          'This is a commentprint "Also notice this comment at the end of the line." : REM This is a comment

Rust

// A single line comment/*    This is a multi-line (aka block) comment    /*        containing nested multi-line comment        (nesting supported since 0.9-pre https://github.com/mozilla/rust/issues/9468)    */*//// Outer single line Rustdoc comments apply to the next item./**    Outer multi-line Rustdoc comments. *  Leading asterisk (*) in multi-line Rustdoc comments *  is not considered to be part of the comment text, *  blanks and tabs preceding the initial asterisk (*) are also stripped.*/fn example() {    //! Inner single line Rustdoc comments apply to their enclosing item.    /*!        Inner multi-line Rustdoc comments.        See also https://github.com/mozilla/rust/wiki/Doc-using-rustdoc    */}#[doc = "Unsugared outer Rustdoc comments.        (outer attributes are not terminated by a semi-colon)"]fn example() {    #[doc = "Unsugared inner Rustdoc comments.            (inner attributes are terminated by a semi-colon)            See also https://github.com/mozilla/rust/blob/master/doc/rust.md#attributes"];}

SAS

/* comment */*another comment;* both  may  be  multiline;

Sather

-- a single line comment

S-BASIC

rem S-BASIC of course allows traditional BASIC-style commentscomment  In addition to the single-line REM statement, S-BASIC   also supports multiline comments using COMMENT...END.  Note that the terminating END must be the first token on  a line of its own.endcomment  When declaring a group of variables, S-BASIC allows  a semi-colon, instead of the normal comma, as a separator,  in which event an explanatory comment can follow the  semi-colon and is ignored by the compiler.endvar n   ; number of payments over life of loan    ppy ; payments per year    apr ; annual interest rate as a decimal    amt ; principal amount of loan    pmt ; amount of periodic payment        = realcomment   Finally, although statements in S-BASIC are normally terminated   by an end-of-line, any logical statement can be continued on to    the following physical line with a backslash, in which event   anything after the backslash is ignored and can be used for    a comment. end if amt = 0 then      \ user forgot to enter a value   print "Must specify a loan amount!"end

Scala

// A single line comment/* A multi-line    comment */

Scheme

; Basically the same as Common Lisp; While R5RS does not provide block comments, they are defined in SRFI-30, as in Common Lisp :#| comment... #| nested comment... |#|#; See http://srfi.schemers.org/srfi-30/srfi-30.html

Scilab

// this is a commenti=i+1 // this is a comment

sed

# a single line comment

Seed7

# A single line comment(* A multi-line     comment *)(* In Seed7, (* comments can be nested. *) *)

SenseTalk

#   Hashtag is a comment--  Dash dash is another comment//  Slash slash is yet another comment—   Alt/Option + Underscore creates an m-dash comment(*  Parentheses and star is used for commentingblocks of code (* and can be nested *) *)set foo to true // all comments can append to statements

Set lang

> Comments start where a > (greater than symbol) startsset a 0 > Comments may start after a Set command

SETL

print("This is not a comment"); -- This is a comment$ For nostalgic reasons, this is also a comment.

Sidef

# this is commented

var i = 1; # this is the comment part

var distance #`{in meters} = (30 #`{meters} * 100 #`{seconds});say distance; # prints: 3000

/*    This is a multi-line comment*/

Simula

COMMENT This is a comment for Simula 67;

!This is a comment for Simula 67;

!OutText("Dying."); !Outimage; !terminate_program;

Slate

"basically the same as smalltalk"

Smalltalk

"Comments traditionally are in double quotes.""Multiline comments are also supported. Comments are saved as metadata along with the source to a method. A comment just after a method signature is often given to explain the usage of the method. The class browser may display such comments specially."

smart BASIC

'Single line comments are preceded by a single quote or the command REMPRINT "Hello" 'Single line comments may follow codePRINT "Hello" REM You can also use the command REM following code/*Multi-line commentsare surrounded bymirrored slashand asterisk *//*Multi-line comments do not have to actually have multiple lines*//* Spaces before or after comment bounds are optional.*//* A comment can also follow another comment */  'Like thisSome programmers like to do this to allow for /* Procedural comments */ followed by 'Programmer's notes.

SNOBOL4

* An asterisk in column 1 is the standard Snobol comment* mechanism, marking the entire line as a comment. There* are no block or multiline comments.*               Comments may begin at*               any position on the line.- A hyphen in column 1 begins a control statement. - Unrecognized control statements are ignored and- may also mark comment lines. Not recommended.                   ;* The semicolon statement separator    output = 'FOO' ;* begins a new statement. This idiom    output = 'BAR' ;* simulates an asterisk in the first                   ;* column, allowing end of line comments.ENDAny text after the required END label is ignored.

SNUSP

SPL

'This is single-line comment''This ismultiline comment''

SQL

SELECT * FROM mytable -- Selects all columns and rows

-- Selects all columns and rowsSELECT * FROM mytable

SELECT * FROM mytable -- Selects all columns and rows

SQL PL

--This is a single line comment.

/* This isa multilinecomment */

(= This isa multilinecomment =)

declare myvar number; --This is an end of line comment.

Squirrel

//this is a single line comment#this is also a single line comment/*    this is a multi-line comment*/

SSEM

00101010010001000100100100001100

Standard ML

(* This a comment   (* containing nested comment *) *)

Stata

* Line comment: must be used at the beginning of a line (does not work in Mata)// Line comment until the end of the line/* Multiline comment*/

Stax

SuperTalk

-- This is a comment

Swift

// this is a single line comment/* This a block comment   /* containing nested comment */ *////This is a documentation comment/**  This is a documentation block comment*/

Symsyn

| This is a comment

Tcl

# comment on a line by itself. The next is a command by itself:set var1 $value1set var2 $value2 ; # comment that follows a line of code

set aList {foo}lappend aList # barputs $aList           ;# ==> prints "foo # bar"puts [llength $aList] ;# ==> 3

if 0 {   Comments...}

Tern

TI-83 BASIC

:"THIS IS A COMMENT

:If 0:THIS IS A COMMENT

TI-89 BASIC

© This is a comment. Everything from © to the end of the line is ignored.

Tiny BASIC

10 REM this is a comment2040 REM from above you can see that line numbers with no statement50 REM and blank lines also are ignored

Toka

#! Everything on this line (after the shebang to the left) will be ignored.

[ ( a b -- c )   ... ] is myword

( This is a  simple, multi-line  comment )

... code ....end.Nothing following the end. will be evaluated by Toka.

TorqueScript

//This is a one line comment. There are no other commenting options in TorqueScript.

TPP

--## comments are prefixed with a long handed double paintbrush

Transd

// This is a line comment./* This is a single line block comment.*//* This is   a multi-line   block comment.*/

TUSCRIPT

$$ MODE TUSCRIPT- This is a comment

TXR

@# old-style comment to end of line@; new-style comment to end of line@(bind a ; comment within expression       "foo")

Uiua

UNIX Shell

#!/bin/sh# A leading hash symbol begins a comment.echo "Hello"      # Comments can appear after a statement.# The hash symbol must be at the beginning of a word.echo This_Is#Not_A_Comment#Comment

C Shell

#!/bin/csh -f# C Shell has a similar comment syntax, but only allows comments in a# script file, not in terminal input.echo Hello#With C Shell, the hash can also be in the middle of a word.

es

# Comments in es (extensible shell) look like those of other shells.echo Hello#With es, the hash can also be in the middle of a word.

Unlambda

Ursa

# this is a comment# this is another comment

Ursala

# this is single line a comment# this is a\continued comment(# this is amulti-line comment #)(# comments in (# this form #) can (# be (# arbitrarily #) #) nested #)---- this is also a comment\and can be continued###The whole rest of the file after three hashesis a comment.

Commenting out code

x = <1,## 2,3>

a =<   'to',   ## <      'be',      'or'>,   'not',   'to',   ## 'be'>

foo = 1##bar = 2baz = 3

Comments in compiled files

#comment -[I document the source text but will also be embedded inthe output library or executable file.]-#comment gpl'3'

Comments as diagnostics

my_input_type%C f

my_input_type%Ck f

Comments as hooks

#depend <this,expression> is (parsed)* but {   otherwise,   ignored}

Uxntal

(    Print a hex byte to decimal.)( macros )%\n { 0a }%newline { [ LIT2 \n -Console/write ] DEO }( devices )|10 @Console/vector $2 &read $1 ( &pad is unused ) &pad $5 &write $1 &error $1( main program )|100 @on-reset ( -> )#42 print/dec newlineBRK( library )@print/dec ( dec -- )DUP #64 DIV /dec/tryDUP #0a DIV /dec/try( >> )&dec/num ( num -- )#0a DIVk MUL SUB [ LIT "0 ] ADD .Console/write DEOJMP2r&dec/try ( num -- )DUP ?/dec/numPOP JMP2r

Output:

VBA

' This is a VBA comment

VBScript

' This is a VBScript comment

Verbexx

////////////////////////////////////////////////////////////////////////////////////////////////// Line Comments: // =============//@VAR v1 = 10; // Line comments start from the "//" and continue to end of the line. //               (normal code can appear on the same line, before the //)////   Line comments can span a complete line, or start in the middle of a line./////// Additional // chars and /* /*  /[  ]/ and  /] are ignored//// Line comments can be appear to be nested, since any additional // is ignored./////   Note: // can appear in strings without triggering a line comment//         // cannot appear inside an operator (or verbname), since a line comment//            would start////////////////////////////////////////////////////////////////////////////////////////////////******************************************************************************************** * *  Block Comments: *  ============== * ********************************************************************************************///* //*  These start with /* and end with the next */ .  They cannot be nested, since the first */  //*  will end the block comment.  For example, the comment, /* /* */ */ would end after the     //*  first */. Note that /* is ignored inside a block comment, as are   //   /[   /] and  /].//* //*  Also note that something like the following will cause trouble in a block comment://* //*    /* comments                          ////*     * more comments                     //   */  (the // does not prevent the */ from ending    //*     * (no longer part of the comment)   //        block comment)//*     *///* //*    Note: /* can appear in strings without triggering the start of a block comment//*          /* cannot appear inside an operator (or verbname), since a line comment will//*             start, although */ is allowed inside an operator (verbname).  Commenting//*             out such a verbname may cause problems.//* //*    Note: Since string literals are not recognized in block comments, */ appearing//*          in a string literal inside a block comment (perhaps commented-out code)//*          will cause the block comment to end.  //* //*    Note: It is an error to start a block comment and not end it, so that it is still//*          in progresss when the end-of-file is reached.//* //*    Block comments can appear inside lines of code:  //* /*1*/@VAR/*2*/v2/*3*/=/*4*/20/*5*/;/*6*/  // a line comment can follow block comments on the                                            // same line/[][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][] /[]                                                                                          [] /[]     Nestable Block Comments:                                                             [] []     ========================                                                             []/ []                                                                                          []/ [][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][]/ //[] //[]  These start with /[ and end with the next matching ]/ .  Additional occurrences//[]  of /[ ... ]/ can appear inside a nestable block comment.  The nestable block comment    //[]  will end only when the nest level reaches 0.  Note that /* is ignored inside a nestable     //[]  block comment, as are  */   //  and  /].//[]//[]  Nestable block comments can be used to comment out blocks of code containing line //[]  comments or regular comments, and even balanced and well-formed nestable block comments.//[] //[]    Note: /[ can appear in strings without triggering the start of a block comment.  //[]          However, strings literals are not recognized inside a nestable block comment, so//[]          any appearances of /[ and /] inside a string literal in a nestable block commment //[]          will affect the nest level, and may cause problems.//[] //[]    Note: It is an error to start a nestable block comment and not end it, so that it is//[]          still in progresss when the end of file is reached.//[] //[]    Nestable block comments can appear inside lines of code:  //[] /[1]/@VAR/[2]/v3/[3]/=/[4]/30/[5]/;/[6]/  // a line comment can follow nestable block comments                                           // on the same line@SAY v1 v2 v3;                            // should see:   10 20 30/]/=================================================================================================\|                                                                                                 ||   /] starts a block comment that lasts until the end of the current file.  Everything after     ||   the /] is ignored.                                                                            ||                                                                                                 |\=================================================================================================/

Verilog

// Single line commment. /*    Multiple   line   comment.*/

VHDL

-- Single line commment in VHDL

Vim Script

let a = 4 " A valid commentecho "foo" " Not a comment but an argument that misses the closing quote

Visual Basic

'commentRem comment#If 0  Technically not a comment; the compiler may or may not ignore this, but the  IDE won't. Note the somewhat odd formatting seen here; the IDE will likely  just mark the entire line(s) as errors.#End If

Visual Basic .NET

' This is a commentREM This is also a commentDim comment as string ' You can also append comments to statementsDim comment2 as string REM You can append comments to statements

Visual Objects

// This is a comment/* This is a comment */* This is a comment&& This is a commentNOTE This is a commen

V (Vlang)

Vorpal

# single line comment

Wart

# single-line comment

Wren

// This is a line comment./* This is a single line block comment.*//* This is   a multi-line   block comment.*//* This is/* a nested */block comment.*/

X10

// This is a single line comment/*   This comment spans  multiple lines*/

XLISP

; this is a comment

Xojo

// Comments are denoted by a preceding double slash or or single quote' and continue to the end of the line. There are no multi-line comment blocksDim foo As Integer // Comments can also occupy the ends of code lines

XPL0

Text(0, \comment\ "Hello \not a comment\ World!"); \comment

 Text(0, "Hello World");  \comment\Text(0, "Hello World"); \\comment

\\Text(0, \comment\ "Hello \not a comment\ World"); \comment

cond false;Text(0, "Hello World"); \commentCrLf(0);cond true;

XQuery

(: This is a XQuery comment :)

XSLT

<!-- Comment syntax is borrowed from XML and HTML. -->

XUL

<!-- Comment syntax is borrowed from XML and HTML. -->

Yacas

// This is a single line comment/*   This comment spans  multiple lines*/

Z80 Assembly

 ld hl,&8000  ;This is a comment

Zig

// This is a normal comment in Zig/// This is a documentation comment in Zig (for the following line)

zkl

x=1; // comment ala C++x=2; # ala scripts/* ala C, these comments are parsed (also ala C) *//* can /* be */ nested */#if 0  also ala C (and parsed)#endif#<<<#  "here" comment, unparsed#<<<#

Zoea

program comments        # this program does nothing# zoea supports single line comments starting with a '#' char/*  zoea also supports   multi line  comments*/

Zoea Visual

zonnon

(* this is a comment *)(*    and this is a   multiline comment   (* with a nested comment *)*)