Reto:

En el lenguaje de programación que elija, no ingrese y envíe el nombre de su lenguaje de programación.

Lo suficientemente justo, ¿verdad?

Restricciones

• No puede usar ningún carácter que esté incluido en el nombre de su lenguaje de programación en su código. Por ejemplo, si uso Batch, no debo usar los caracteres 'B' 'a' t '' c '' h 'en mi código. Tenga en cuenta que esto distingue entre mayúsculas y minúsculas. Todavía puedo usar el carácter 'b' porque es diferente de 'B'.
• Puede tener "salida basura" antes o después del nombre del idioma
• El número de versión no cuenta como parte del nombre del idioma. Por ejemplo, puedo usar el número 3 en el código en mi respuesta si está en Python 3
• La salida del nombre del lenguaje de programación no distingue entre mayúsculas y minúsculas.
• Está prohibido forzar todas las combinaciones de letras posibles y esperar que obtenga el nombre de su idioma.

Resultados de ejemplo: (digamos que mi lenguaje de programación se llama Language) (✔ si es válido, de lo contrario ✖)

• Language ✔
• Body language is a type of non-verbal communication in which physical behavior, as opposed to words, is used to express or convey information. Such behavior includes facial expressions, body posture, gestures, eye movement, touch and the use of space. ✔
• Language 2.0 - © 1078 AD some company ✔
• foobar ✖

Este es el código de golf, por lo tanto, el código más corto gana.

Salidas a STDERR

La salida a STDERR ahora está en + 33 / -21 como un valor predeterminado permitido, que es positivo pero impugnado. Esta es una respuesta CW para recopilar respuestas que solo invocan un error en un idioma donde los mensajes de error incluyen el nombre del idioma.

Haskell, 1 byte

1

Error:

Parse error: naked expression at top level
Perhaps you intended to use TemplateHaskell

Lua, 1 byte

1

Error:

lua: .code.tio:1: syntax error near <eof>

(el nombre del archivo no es importante)

Lote, 1 byte

~

Error:

'~' is not recognized as an internal or external command,
operable program or batch file.

tinylisp, 5 bytes

(c()1

Error:

Error: cannot cons to Int in tinylisp

R, 1 byte

)

Error:

Error: unexpected ')' in ")"

Código de bytes de Java, 0 bytes

Error:

Exception in thread "main" java.lang.ClassFormatError: Truncated class file

Groovy, 1 byte

a

Tenga en cuenta que ase puede reemplazar con cualquier otro personaje

Error:

groovy.lang.MissingPropertyException: No such property: a ...

MATLAB, 1 byte

\

Error:

Error: Unexpected MATLAB operator.

PHP, 3 bytes

<?=

Error:

PHP Parse error:  syntax error, unexpected end of file in /home/runner/.code.tio on line 1

CJam, 1 byte

/

Error:

/
^
RuntimeException: The stack is empty
Java exception:
java.lang.RuntimeException: The stack is empty
    at net.aditsu.cjam.CJam.pop(CJam.java:75)
    at net.aditsu.cjam.Op2.run(Op2.java:10)
    at net.aditsu.cjam.Block.run(Block.java:304)
    at net.aditsu.cjam.CJam.runCode(CJam.java:210)
    at net.aditsu.cjam.CJam.main(CJam.java:240)

Ramita, 2 bytes

Twig es un lenguaje de plantilla escrito en PHP. Es posible que este sea un políglota.

{{
{%
{#

Error:

PHP Fatal error:  Uncaught exception 'Twig_Error_Syntax' with message [...] in [...][...]:n:
Stack trace:
#0 [...]

El mensaje varía según el programa que elija.

SILOS , 2 bytes

x+

Pruébalo en línea! Invoca trivialmente el comportamiento indocumentado. Silos es el nombre de la lengua.

Python, 6 bytes

pYTHON

Como la restricción de caracteres no distingue entre mayúsculas y minúsculas, y la salida no tiene que estar en el caso correcto, esta es una respuesta válida. El mensaje de error que produce es algo como esto:

Traceback (most recent call last):
  File ".code.tio", line 1, in <module>
    pYTHON
NameError: name 'pYTHON' is not defined

Pruébalo en línea! (salidas a la pestaña 'depurar')

JavaScript, 10 bytes

jAVAsCRIPT

Esto produce el siguiente mensaje de error o similar en todos los entornos:

ReferenceError: jAVAsCRIPT is not defined

QBIC , 6 bytes

?b(12)

En 6 bytes, podemos poner el error QBIC encontrado: 9 en la pantalla, lo que significa un error fuera de límites.

ForceLang, 2 bytes

()

Error producido:

Exception in thread "main" lang.exceptions.IllegalInvocationException: null is not a function.
    at lang.ForceLang.parse(ForceLang.java:99)
    at lang.ForceLang.main(ForceLang.java:129)

Pip, 5 bytes

1~`[`

(Nota: esto funciona en la versión actual a partir de este escrito, 0.17.09.01 . No hay garantías de que el intérprete no cambie para manejar este error de manera diferente en el futuro).

Intenta que la expresión regular coincida con un patrón sintácticamente inválido. El error producido se verá así:

Traceback (most recent call last):
  File "/opt/pip/pip.py", line 221, in <module>
    pip(interactive=False)
  File "/opt/pip/pip.py", line 206, in pip
    state.executeProgram(tree, args)
  File "/opt/pip/execution.py", line 56, in executeProgram
    returnVal = self.functionCall(mainFunction, cmdLineArgs)
  File "/opt/pip/execution.py", line 368, in functionCall
    returnVal = self.getRval(returnExpr)
  File "/opt/pip/execution.py", line 235, in getRval
    expr = self.evaluate(expr)
  File "/opt/pip/execution.py", line 213, in evaluate
    result = opFunction(*args)
  File "/opt/pip/execution.py", line 1134, in FIRSTMATCH
    matchObj = regex.asRegex().search(str(string))
  File "/opt/pip/ptypes.py", line 175, in asRegex
    self._compiled = re.compile(pyRegex)
  File "/usr/lib64/python3.6/re.py", line 233, in compile
    return _compile(pattern, flags)
  File "/usr/lib64/python3.6/re.py", line 301, in _compile
    p = sre_compile.compile(pattern, flags)
  File "/usr/lib64/python3.6/sre_compile.py", line 562, in compile
    p = sre_parse.parse(p, flags)
  File "/usr/lib64/python3.6/sre_parse.py", line 855, in parse
    p = _parse_sub(source, pattern, flags & SRE_FLAG_VERBOSE, 0)
  File "/usr/lib64/python3.6/sre_parse.py", line 416, in _parse_sub
    not nested and not items))
  File "/usr/lib64/python3.6/sre_parse.py", line 765, in _parse
    p = _parse_sub(source, state, sub_verbose, nested + 1)
  File "/usr/lib64/python3.6/sre_parse.py", line 416, in _parse_sub
    not nested and not items))
  File "/usr/lib64/python3.6/sre_parse.py", line 523, in _parse
    source.tell() - here)
sre_constants.error: unterminated character set at position 8

Stax, 2 bytes

0u

Error:

Stax runtime error: rational divide by zero

zh También funciona.

tinta, 1 byte

~

~al comienzo de una línea marca que la línea es una declaración a ejecutar, en lugar de texto a imprimir. A partir de la versión de inklecate que utilice TIO, si no hay nada después ~, el intérprete falla con el siguiente error:

System.NullReferenceException: Object reference not set to an instance of an object
  at Ink.InkParser.LogicLine () [0x000b1] in <b1e5e74f4ee842fc961297862cf23e07>:0 
  at Ink.StringParser.ParseObject (Ink.StringParser+ParseRule rule) [0x00012] in <b1e5e74f4ee842fc961297862cf23e07>:0 
  at Ink.StringParser.OneOf (Ink.StringParser+ParseRule[] array) [0x0000a] in <b1e5e74f4ee842fc961297862cf23e07>:0 
  at Ink.InkParser.StatementAtLevel (Ink.InkParser+StatementLevel level) [0x00009] in <b1e5e74f4ee842fc961297862cf23e07>:0 
  at Ink.InkParser+<>c__DisplayClass134_0.<StatementsAtLevel>b__0 () [0x00000] in <b1e5e74f4ee842fc961297862cf23e07>:0 
  at Ink.StringParser.ParseObject (Ink.StringParser+ParseRule rule) [0x00012] in <b1e5e74f4ee842fc961297862cf23e07>:0 
  at Ink.StringParser.Interleave[T] (Ink.StringParser+ParseRule ruleA, Ink.StringParser+ParseRule ruleB, Ink.StringParser+ParseRule untilTerminator, System.Boolean flatten) [0x00040] in <b1e5e74f4ee842fc961297862cf23e07>:0 
  at Ink.InkParser.StatementsAtLevel (Ink.InkParser+StatementLevel level) [0x0004f] in <b1e5e74f4ee842fc961297862cf23e07>:0 
  at Ink.InkParser.Parse () [0x00000] in <b1e5e74f4ee842fc961297862cf23e07>:0 
  at Ink.Compiler.Compile () [0x00033] in <b1e5e74f4ee842fc961297862cf23e07>:0 
  at Ink.CommandLineTool..ctor (System.String[] args) [0x001a3] in <d64e27e7788347b2a5377c9e19bbdcab>:0 
  at Ink.CommandLineTool.Main (System.String[] args) [0x00000] in <d64e27e7788347b2a5377c9e19bbdcab>:0 
[ERROR] FATAL UNHANDLED EXCEPTION: System.NullReferenceException: Object reference not set to an instance of an object
  at Ink.InkParser.LogicLine () [0x000b1] in <b1e5e74f4ee842fc961297862cf23e07>:0 
  at Ink.StringParser.ParseObject (Ink.StringParser+ParseRule rule) [0x00012] in <b1e5e74f4ee842fc961297862cf23e07>:0 
  at Ink.StringParser.OneOf (Ink.StringParser+ParseRule[] array) [0x0000a] in <b1e5e74f4ee842fc961297862cf23e07>:0 
  at Ink.InkParser.StatementAtLevel (Ink.InkParser+StatementLevel level) [0x00009] in <b1e5e74f4ee842fc961297862cf23e07>:0 
  at Ink.InkParser+<>c__DisplayClass134_0.<StatementsAtLevel>b__0 () [0x00000] in <b1e5e74f4ee842fc961297862cf23e07>:0 
  at Ink.StringParser.ParseObject (Ink.StringParser+ParseRule rule) [0x00012] in <b1e5e74f4ee842fc961297862cf23e07>:0 
  at Ink.StringParser.Interleave[T] (Ink.StringParser+ParseRule ruleA, Ink.StringParser+ParseRule ruleB, Ink.StringParser+ParseRule untilTerminator, System.Boolean flatten) [0x00040] in <b1e5e74f4ee842fc961297862cf23e07>:0 
  at Ink.InkParser.StatementsAtLevel (Ink.InkParser+StatementLevel level) [0x0004f] in <b1e5e74f4ee842fc961297862cf23e07>:0 
  at Ink.InkParser.Parse () [0x00000] in <b1e5e74f4ee842fc961297862cf23e07>:0 
  at Ink.Compiler.Compile () [0x00033] in <b1e5e74f4ee842fc961297862cf23e07>:0 
  at Ink.CommandLineTool..ctor (System.String[] args) [0x001a3] in <d64e27e7788347b2a5377c9e19bbdcab>:0 
  at Ink.CommandLineTool.Main (System.String[] args) [0x00000] in <d64e27e7788347b2a5377c9e19bbdcab>:0 

SmileBASIC, 11 bytes

sPsET.,1474

Equivalente a SPSET 0,1474. Establece el sprite 0 en la definición 1474, que es el logotipo de SmileBASIC.

MATL , 1 byte

Y

La salida es a través de STDERR, que está permitido por defecto .

La salida del compilador fuera de línea es

Error using matl_parse (line 339)
MATL error while parsing: Y not recognized at position 1
Error in matl (line 234)
    S = matl_parse(s, useTags); 

O pruébalo en línea! (expanda la sección "depuración").

R, 1 byte:

T

Tes un alias para la constante TRUE. Entonces la salida para lo anterior es:

[1] TRUE

Como se permite la basura alrededor del nombre, la "R" allí es el nombre del idioma.

( Como se señaló en un comentario en otra parte , prácticamente cualquier letra y muchos glifos funcionarán igual de bien porque activan el mensaje "Error: ...", que contiene "r").

HTML, 24 20 bytes

HTML

HTML, 16 bytes

Como señaló @Bob , los navegadores modernos reconocerán las entidades HTML sin punto y coma, aunque es un HTML técnicamente inválido. Por supuesto, es perfectamente válido para el golf de código.

&#72&#84&#77&#76

HTML, 4 bytes

Y, por supuesto, la respuesta poco interesante.

html

Además, vea mi respuesta CSS .

Vim, 0 bytes

Cuando inicia Vim, el editor muestra una pantalla de presentación que se ve así:

Puedes ver que dice Vimaquí:

Respuesta anterior:

Vim, 1 byte

<Ctrl-C>

En Vim 8, al presionar se mostrará Type :quit<Enter> to exit Vimen la última línea. No estoy completamente seguro si esto cuenta.

Python, 15 bytes

Pitón 2 (15)

exec"\150elp()"

Concatena las cadenas utiliza el octal 150que es hy "elp()", y corre el resultado. Esto imprime el help()comando que dice "Welcome to Python 3.5's help utility!", cumpliendo los requisitos.

Pitón 3 (17)

exec("\150elp()")

Pruébalo en línea!

C, 0 bytes.

/usr/lib/gcc/i586-linux-gnu/5/../../../i386-linux-gnu/crt1.o: In function `_start':
(.text+0x18): undefined reference to `main'
collect2: error: ld returned 1 exit status

Pruébalo en línea!

¿Eh ?, 0 bytes

^{(no, no hay nada en ese bloque de código)}

El idioma se llama por su salida, así que ...

En la implementación que verifiqué , el intérprete toma la longitud mod 8 de cada línea de un archivo determinado y cambia según el resultado. Para cero, se imprime Huh?. Como elimina las nuevas líneas finales, también puede hacer una \nversión de 1 byte ( ).

Tenga en cuenta que no se está enviando a stderr o casos de intercambio o cualquier otro truco. Es solo que el muy confundido intérprete de Huh finalmente fue útil.

V , 2 bytes

¬U

Pruébalo en línea!

La respuesta obvia es:

év~

Pruébalo en línea!

Que es "Insertar la letra 'v', y alternar mayúsculas y minúsculas". Sin embargo, dado que permite la salida de basura antes / después del nombre del idioma, esto también funciona.

El ¬comando toma dos caracteres para la entrada e inserta cada carácter ASCII entre ellos. Si no proporcionamos el segundo carácter, el valor predeterminado es automáticamente ÿ(ASCII 0xff), por lo que este programa inserta todos los caracteres en la codificación latin1 entre Uy ÿ.

brainfuck , 54 bytes

+[[-<]-[->]<-]<.<<<<.>>>>-.<<-.<.>>.<<<+++.>>>---.<++.

Salidas brainfuck, suponiendo que una cinta de 8 bits se abra a la izquierda. Pruébalo en línea!

Como siempre, los créditos parciales van a Hello, World de @primo! contestar .

Alternativas con diferentes carcasas

Brainfuck (62 bytes):

+[<-[-<]-[->]<<]<---.<<<<<<--.>>>-.<+.<.>---.<<+++.>>---.<---.

BrainFuck (68 bytes):

-[[-<]->+[->]<-]<<.<<<<<--.>>+.<-.+++++.>>>------.<<<<+++.>>++.<---.

MATLAB, 3 bytes

ver

La salida es la siguiente. La información irrelevante ha sido reemplazada por [...]). Algunas partes de la salida pueden cambiar según la versión, las cajas de herramientas instaladas, etc.

-----------------------------------------------------------------------------------------
MATLAB Version: 8.6.0.267246 (R2015b)
MATLAB License Number: [...]
Operating System: [...]
Java Version: Java 1.7.0_60-b19 with [...]
-----------------------------------------------------------------------------------------
MATLAB                                                Version 8.6         (R2015b)
Communications System Toolbox                         Version 6.1         (R2015b)
Curve Fitting Toolbox                                 Version 3.5.2       (R2015b)
[...]
Wavelet Toolbox                                       Version 4.15        (R2015b)

Python, 27 53 49 48 45 bytes

-3 bytes de @ wizzwizz4

exec eval('"IMpORT THIS".LOWER()'.swapcase())

Imprime el siguiente texto, que tiene "Python" en la primera línea.

The Zen of Python, by Tim Peters

Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren't special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one-- and preferably only one --obvious way to do it.
Although that way may not be obvious at first unless you're Dutch.
Now is better than never.
Although never is often better than *right* now.
If the implementation is hard to explain, it's a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea -- let's do more of those!

Python 2 (1 byte)

è

salida...:

> <> , 12 10 bytes

"2,:o:2-o|

Esto imprimirá continuamente> <> hasta que el intérprete se quede sin espacio.

Pruébalo en línea!

Versión de 12 bytes a continuación para aquellos que gustan de una salida limpia. Recomendado por Aaron (sin error, 1 salida)

":3+:o$1+oo;

JAVA, 1 byte

1

La salida a stderr es:

Main.java:1: error: class, interface, or enum expected
1
^
1 error
Error: Could not find or load main class Main
Command exited with non-zero status 1
    Command being timed: "/srv/wrappers/java-openjdk"
    User time (seconds): 1.40
    System time (seconds): 0.80
    Percent of CPU this job got: 40%
    Elapsed (wall clock) time (h:mm:ss or m:ss): 0:05.40
    Average shared text size (kbytes): 0
    Average unshared data size (kbytes): 0
    Average stack size (kbytes): 0
    Average total size (kbytes): 0
    Maximum resident set size (kbytes): 44564
    Average resident set size (kbytes): 0
    Major (requiring I/O) page faults: 205
    Minor (reclaiming a frame) page faults: 11301
    Voluntary context switches: 2666
    Involuntary context switches: 1677
    Swaps: 0
    File system inputs: 78312
    File system outputs: 0
    Socket messages sent: 0
    Socket messages received: 0
    Signals delivered: 0
    Page size (bytes): 4096
    Exit status: 1 

CSS, 25 bytes

:after{content:'\43\53\53

Tenga en cuenta que se agrega marcado adicional a los fragmentos de desbordamiento de pila, lo que hace que "CSS" se muestre más de una vez. Abrir un .htmlarchivo con contenido

<style>:after{content:'\43\53\53

para ver el resultado según lo previsto.

golpe CLI, 9

printf $0

Si desea un script real y no solo un comando en la línea de comandos interactiva, puede hacer esto:

bash, 13

printf $SHELL

Salidas /bin/bash

C, 15 bytes

C compilado en una máquina Linux con una configuración regional alemana:

main(){main();}

Se ejecutará en un desbordamiento de pila e imprimirá Speicherzugriffsfehler(alemán para el fallo de segmentación) en stderr.

dc, 6

25699P

Salidas dc.

Pruébalo en línea .

Pip , 8 bytes

'IWR C80

Toma el carácter Iy lo WRaps en Chr ( 80), lo que resulta en PIP. Pruébalo en línea!

Usar el se Isiente un poco como hacer trampa, así que aquí hay dos soluciones de 9 bytes que no usan ninguno de PpIi:

z@8WRz@15
(z8+^707)

Ambas salidas pip. Estoy particularmente satisfecho con el segundo:

    ^707   Split 707 into a list of characters        [7;0;7]
  8+       Add 8 to each one                          [15;8;15]
(z      )  Use list to index into lowercase alphabet  ["p";"i";"p"]
           By default, lists are printed without a separator

Para una capitalización adecuada, necesitamos una solución de 10 bytes :

'IWR C80Vx

Cómo funciona éste se deja como ejercicio para el lector. ; ^)

C #, 60 67 bytes

class P{static void Main(){System.\u0043onsole.Write("\x43\x23");}}

brainfuck, 105 bytes

--[----->+<]>----.[--->+<]>----.+++[->+++<]>++.++++++++.+++++.--------.-[--->+<]>--.+[->+++<]>+.++++++++.

Pruébalo en línea aquí

R , 11 bytes

cat("\x52")

Pruébalo en línea!

Adelante, 5 bytes

WORDS

Pruébalo en línea

Imprime una lista de cada palabra en el idioma. Forthestá en la lista (primera palabra en la línea 125), aunque no sé qué hace.

Hexagonía , 19 bytes.

Básicamente un flujo lineal directo envuelto dentro del hexágono.

h;E;N;Y;X;A;;@/OG;/

¡Pruebe esta solución poco interesante de 19 bytes en línea!

28 bytes más interesantes:

I] f. @] Z;. (; [. $>] Z (] b] \ (] p] h <

Pruébalo en línea!

Esto usa el pequeño h, que está permitido. Utiliza el IP1 (Inicial es 0) como una "función" que hace "Decrementar e imprimir como char".

Vista ampliada

   I ] f .
  @ ] z ; .
 ( ; [ . $ >
] z ( ] b ] \
 ( ] p ] h <
  . . . . .
   . . . .

Guarda Ien la memoria, vaya al siguiente puntero de instrucciones con ], luego IP1 se ejecuta desde la esquina NE en dirección SE y golpea ..>que dirige a E, envuelto a las 5 no-operaciones inferiores .y luego a ((decremento), ;(imprimir como char) y entonces [que vuelve a IP0.

IP0 comienza a leer desde donde se detuvo f, pasa por el no-op .y al medio ]que ejecuta la "función" de nuevo: IP1 comienza desde donde se detuvo y golpea el no-op, .luego se $salta >y vuelve a pasar por la parte inferior. para imprimir e.

El programa sigue haciendo cosas así. Descubrí que podría haber impreso simplemente nllamando a la función nuevamente después de imprimir o. Mm ... no se me ocurren formas de acortar esto aún más, aunque reemplazo 1 byte por no-op con este descubrimiento.

¡Déjame un comentario si quieres ver diagramas en esta explicación!

J, 2 bytes

   a.


┌┬┐├┼┤└┴┘│─ !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~��������������������������������������������������������������������������������������������������������������������������������

a. devuelve el alfabeto del lenguaje J, una lista integrada de todos los bytes.

Mi original: 4 bytes

   %:_1
0j1

Esto me parece genial. La raíz cuadrada ( %:) del negativo 1 ( _1) es i ( 0j1).

BÁSICO (ZX Spectrum), 4 2 bytes

tachado 4 sigue siendo regular 4

Guardado 2 bytes gracias a @ShaunBebbers.

0õ

Nota: en el juego de caracteres ZX Spectrum, estos bytes se muestran como

0 PRINT

Cuando ingresa esto, Spectrum comienza analizando un número opcional seguido de una línea de código. Normalmente, el número de línea es lo 1..9999que hace que el código se agregue al programa almacenado. Sin embargo, si no se proporciona un número de línea, el código se ejecuta inmediatamente. Desafortunadamente, un error en Spectrum significa que confunde un número de línea cero con ningún número de línea, pero aún intenta ejecutar el cero como parte de la línea de código, lo cual es ilegal, causando el error.

La versión anterior de 4 bytes genera un error verdadero en lugar de depender de un error de interpretación:

õ°""

Nota: en el juego de caracteres ZX Spectrum, estos bytes se muestran como

PRINT VAL ""

que salidas

C Nonsense in BASIC, 0:1

porque la cadena vacía no es una expresión numérica válida. (Por supuesto, podría haber usado cualquier declaración que tome un solo número entero). Si esta respuesta es inaceptable, entonces para 6 bytes puede escribir un programa que consiste en una sola línea con una de las palabras clave que no acepta argumentos, luego use POKEpara reemplazar con una palabra clave ilegal, luego intente con RUNel programa.

C 24 20 Bytes (Clang 3.8.1)

Gracias a @squeamish ossifrage por ayudarme a ahorrar 4 bytes.

main(){putchar(67);}

Vim, 3 bytes

:h<CR>

Pruébalo en línea!

Esto abre el archivo de ayuda predeterminado y genera:

*help.txt*  For Vim version 7.4.  Last change: 2016 Mar 31

                        VIM - main help file
                                                                         k
      Move around:  Use the cursor keys, or "h" to go left,        h   l
                    "j" to go down, "k" to go up, "l" to go right.   j
Close this window:  Use ":q<Enter>".
   Get out of Vim:  Use ":qa!<Enter>" (careful, all changes are lost!).

Jump to a subject:  Position the cursor on a tag (e.g. |bars|) and hit CTRL-].
   With the mouse:  Double-click the left mouse button on a tag, e.g. |bars|.
        Jump back:  Type CTRL-T or CTRL-O.  Repeat to go further back.

Get specific help:  It is possible to go directly to whatever you want help
                    on, by giving an argument to the |:help| command.
                    Prepend something to specify the context:  *help-context*

                          WHAT          PREPEND    EXAMPLE  ~
                      Normal mode command          :help x
                      Visual mode command     v_       :help v_u
                      Insert mode command     i_       :help i_<Esc>
                      Command-line command    :    :help :quit
                      Command-line editing    c_       :help c_<Del>
                      Vim command argument    -    :help -r
                      Option              '    :help 'textwidth'
                      Regular expression      /    :help /[
                    See |help-summary| for more contexts and an explanation.

  Search for help:  Type ":help word", then hit CTRL-D to see matching
                    help entries for "word".
                    Or use ":helpgrep word". |:helpgrep|

VIM stands for Vi IMproved.  Most of VIM was made by Bram Moolenaar, but only
through the help of many others.  See |credits|.
------------------------------------------------------------------------------
                                                *doc-file-list* *Q_ct*
BASIC:
|quickref|  Overview of the most common commands you will use
|tutor|     30 minutes training course for beginners
|copying|   About copyrights
|iccf|      Helping poor children in Uganda
|sponsor|   Sponsor Vim development, become a registered Vim user
|www|       Vim on the World Wide Web
|bugs|      Where to send bug reports

USER MANUAL: These files explain how to accomplish an editing task.

|usr_toc.txt|   Table Of Contents

Getting Started ~
|usr_01.txt|  About the manuals
|usr_02.txt|  The first steps in Vim
|usr_03.txt|  Moving around
|usr_04.txt|  Making small changes
|usr_05.txt|  Set your settings
|usr_06.txt|  Using syntax highlighting
|usr_07.txt|  Editing more than one file
|usr_08.txt|  Splitting windows
|usr_09.txt|  Using the GUI
|usr_10.txt|  Making big changes
|usr_11.txt|  Recovering from a crash
|usr_12.txt|  Clever tricks

Editing Effectively ~
|usr_20.txt|  Typing command-line commands quickly
|usr_21.txt|  Go away and come back
|usr_22.txt|  Finding the file to edit
|usr_23.txt|  Editing other files
|usr_24.txt|  Inserting quickly
|usr_25.txt|  Editing formatted text
|usr_26.txt|  Repeating
|usr_27.txt|  Search commands and patterns
|usr_28.txt|  Folding
|usr_29.txt|  Moving through programs
|usr_30.txt|  Editing programs
|usr_31.txt|  Exploiting the GUI
|usr_32.txt|  The undo tree

Tuning Vim ~
|usr_40.txt|  Make new commands
|usr_41.txt|  Write a Vim script
|usr_42.txt|  Add new menus
|usr_43.txt|  Using filetypes
|usr_44.txt|  Your own syntax highlighted
|usr_45.txt|  Select your language


REFERENCE MANUAL: These files explain every detail of Vim.  *reference_toc*

General subjects ~
|intro.txt| general introduction to Vim; notation used in help files
|help.txt|  overview and quick reference (this file)
|helphelp.txt|  about using the help files
|index.txt| alphabetical index of all commands
|help-tags| all the tags you can jump to (index of tags)
|howto.txt| how to do the most common editing tasks
|tips.txt|  various tips on using Vim
|message.txt|   (error) messages and explanations
|quotes.txt|    remarks from users of Vim
|develop.txt|   development of Vim
|debug.txt| debugging Vim itself
|uganda.txt|    Vim distribution conditions and what to do with your money

Basic editing ~
|starting.txt|  starting Vim, Vim command arguments, initialisation
|editing.txt|   editing and writing files
|motion.txt|    commands for moving around
|scroll.txt|    scrolling the text in the window
|insert.txt|    Insert and Replace mode
|change.txt|    deleting and replacing text
|indent.txt|    automatic indenting for C and other languages
|undo.txt|  Undo and Redo
|repeat.txt|    repeating commands, Vim scripts and debugging
|visual.txt|    using the Visual mode (selecting a text area)
|various.txt|   various remaining commands
|recover.txt|   recovering from a crash

Advanced editing ~
|cmdline.txt|   Command-line editing
|options.txt|   description of all options
|pattern.txt|   regexp patterns and search commands
|map.txt|   key mapping and abbreviations
|tagsrch.txt|   tags and special searches
|quickfix.txt|  commands for a quick edit-compile-fix cycle
|windows.txt|   commands for using multiple windows and buffers
|tabpage.txt|   commands for using multiple tab pages
|syntax.txt|    syntax highlighting
|spell.txt| spell checking
|diff.txt|  working with two to four versions of the same file
|autocmd.txt|   automatically executing commands on an event
|filetype.txt|  settings done specifically for a type of file
|eval.txt|  expression evaluation, conditional commands
|fold.txt|  hide (fold) ranges of lines

Special issues ~
|print.txt| printing
|remote.txt|    using Vim as a server or client
|term.txt|  using different terminals and mice
|digraph.txt|   list of available digraphs
|mbyte.txt| multi-byte text support
|mlang.txt| non-English language support
|arabic.txt|    Arabic language support and editing
|farsi.txt| Farsi (Persian) editing
|hebrew.txt|    Hebrew language support and editing
|russian.txt|   Russian language support and editing
|ft_ada.txt|    Ada (the programming language) support
|ft_sql.txt|    about the SQL filetype plugin
|rileft.txt|    right-to-left editing mode

GUI ~
|gui.txt|   Graphical User Interface (GUI)
|gui_w32.txt|   Win32 GUI

Interfaces ~
|if_cscop.txt|  using Cscope with Vim
|if_pyth.txt|   Python interface
|if_ruby.txt|   Ruby interface
|debugger.txt|  Interface with a debugger
|sign.txt|  debugging signs

Versions ~
|vim_diff.txt|  Main differences between Nvim and Vim
|vi_diff.txt|   Main differences between Vim and Vi
                                                *sys-file-list*
Remarks about specific systems ~
|os_win32.txt|  MS-Windows
                                                *standard-plugin-list*
Standard plugins ~
|pi_gzip.txt|      Reading and writing compressed files
|pi_netrw.txt|     Reading and writing files over a network
|pi_paren.txt|     Highlight matching parens
|pi_tar.txt|       Tar file explorer
|pi_vimball.txt|   Create a self-installing Vim script
|pi_zip.txt|       Zip archive explorer

LOCAL ADDITIONS:                *local-additions*

------------------------------------------------------------------------------
*bars*      Bars example

Now that you've jumped here with CTRL-] or a double mouse click, you can use
CTRL-T, CTRL-O, g<RightMouse>, or <C-RightMouse> to go back to where you were.

Note that tags are within | characters, but when highlighting is enabled these
characters are hidden.  That makes it easier to read a command.

Anyway, you can use CTRL-] on any word, also when it is not within |, and Vim
will try to find help for it.  Especially for options in single quotes, e.g.
'hlsearch'.

------------------------------------------------------------------------------
 vim:tw=78:fo=tcq2:isk=!-~,^*,^\|,^\":ts=8:ft=help:norl: