Lista de los lenguajes de programación en orden alfabético

La lista de los lenguajes de programación se compone de todos los idiomas implementados en un compilador o un intérprete, en orden alfabético. Y para los idiomas más recientes, hay por lo menos un programa ampliamente utilizado escrita en esta lengua. 
Además, las lenguas históricas sin compilador, pero que puede haber influido en el diseño de los nuevos trabajos se incluyen también, a condición de que el autor de la lengua más ha hecho una referencia verificable para ellos. 
La mayoría de las entradas en la lista tiene un enlace a un sitio web o una página de descarga para el compilador o intérprete. Para los idiomas históricos, un enlace a una página web específica o una descripción. Otros detalles como la fecha y el tipo de lenguaje puede ser añadido también.

• 
  

La

• A + . 2001 similares a APL.
• A #. Orientado a objetos, lenguaje de programación funcional, sustituido ahora por Aldor.
• Abap . Programación Avanzada de Aplicaciones de Negocio.Lenguaje de programación Cobol como para servidores de aplicaciones web de SAP.
• Abc .
• ¡Acción! lenguaje de programación de diseño del compilador, como Micro-SPL.
• ActionScript. 2004. Versión de ECMAScript for Flash.
• Actor. 1986. Lenguaje de programación y también un concepto para el diseño de lenguajes (actor orientado).
• Ada . 1983.
• Afnix . 1998 Anteriormente Aleph. Lenguaje funcional.
• Agena . 2009. Inspirado de Algol y C.
• Aldor.
• Aleph. Ver Afnix.
• Las algas . Interpretado idioma para el análisis numérico.
• Algo. Lenguaje de programación algebraico.
• Algol . 1958. Seguido de Algol 60, ​​Algol W (Wirth) y Algol 68. Ha inspirado a Pascal.
• Alma-0 . Lenguaje de programación imperativo y lógico.
• Alphard . 1974 Nombre de la estrella más brillante en Hydra. Pascal-like.
• Altran. 1968. Variante Fortran.
• AmigaE . Idioma inspirada en Ada, C + +, Lisp.
• Ampl . Lenguaje de Modelado de Programación Matemática.
• Anubis. 2000. Funcional, no mL, lenguaje.
• ApeScript.
• Apl . 1962. Un lenguaje de programación del compilador FAQ .
• AppleScript . 1993. Lenguaje de programación similar al Inglés.
• APT. Programa automáticamente Herramienta. Lenguaje de alto nivel para las máquinas de control numérico.
• Arduino . Una versión del lenguaje de cableado para el controlador de código abierto Arduino USB.
• Argos. Idioma síncrono.
• ARS . Abstracción, de referencia y de síntesis. Una orientación.Inspirado lenguajes de programación. Existe una ARS + + compilador.
• Asm.js . Subconjunto de JavaScript que se ejecuta más rápido. Es ejecutado por Mozilla.
• AspectJ . Implementación en Java de programación orientada a aspectos. Desarrollo
• Asamblea .
• ATLAS. Varias lenguas menores llevan este apellido.
• Autocode. 1952. Existen varias versiones de esta lengua histórica primitiva.
• AutoIt . Idioma Automation. Originalmente para aplicaciones de secuencias de comandos de Windows, ahora más general.
• Averest . Simultanea, reemplazado por Cuarzo.
• Awk . 1978. Ver también curiosear, nawk, mawk.
• Axiom . Sistema Algrebra ordenador, en realidad un conjunto de herramientas que utiliza la A # lenguaje.

B

• B . 1969.
• Bash . Shell Bourne-Again. En realidad un intérprete Bourne shell.
• Básico . 1964.
• BAL. El lenguaje ensamblador para el IBM 360.
• BCPL (Combined Programming Language Básico). 1966. Compiler .B Inspirado que a su vez inspiró C.
• BeanShell .
• Beta .
• Bigwig .
• Bistro . 1999. Smaltalk y Java como.
• Dicha.
• Blocky . 2012 por Google. Lenguaje gráfico, el bloque se mueven para crear una aplicación.
• BODOL . 2013. Lenguaje funcional, combinación de Haskell y Clojure con tipos Hindley-Milner.
• Boo . 2004.
• Shell Bourne . (Sh) 1978. Lenguaje de comandos de Unix.
• BPEL . Business Process Execution Language

C

• C . 1972.
• C - . 1997. Lenguaje intermedio portátil dirigido a los compiladores.A diferencia de LLVM, una interfaz en tiempo de ejecución para agregar procesamientos tales como un recolector de basura.Descargar .
• C + + . 1980. El estándar es C + + 98 y C + + 09 deben tener éxito en 2009.
• C # . 2000.
• C Shell.
• Escritura de Objetos Caché . Lengua de procedimiento con las funciones de base de datos. Compatible con paperas.
• Caml . Categórico Abstract Machine Language.
• Cayenne. Functionnal, cerca de Haskell con características de Java.
• Cecil . 1992 Cerca de Modula y Objective C. (Buscar en el sitio).
• CeeBot.
• Ceilán . 2012. Creado por Red Hat para escribir colectivamente programas grandes y usar datos estructurados. Al igual que con JavaScript clases e interfaces, pero se ejecuta en una máquina virtual Java. Nota: Ceylan = té, Java = café.
• CFScript. JavaScript parte de ColdFusion. Ver también CFML.
• Decimosexto .
• Caridad. Funcional y categórica lenguaje de programación.
• CHILL . Idioma de las telecomunicaciones. Chill 96 es orientado y genéricos objeto.
• CHR . Restricción Manejo Reglas.
• Chrome.
• ChucK . Lenguaje concurrente Multimedia para la síntesis de audio y otras tareas musicales.
• Cilk . Multi-hilo y concurrente basado en C.
• Clarion .
• Arcilla . 2004. Lenguaje Seguro para la construcción o la verificación de los dispositivos.
• Arcilla . 2011. Para la programación genérica.
• Clean . Concurrente Limpio.
• Clipper. 1984.
• CLIPS. Sistema de Producción Integrada C Idioma. Ver fresco.
• Clojure . 2007. Lisp tipo, compila a la JVM.
• CLOS. Ver Common Lisp.
• Clu . Ha inspirado a Ruby.
• Cobol . 1959. Common Business Oriented Language. Inspirado por Flow-matic, Fortran. Los estándares ANSI son Cobol 58, 74, 85 y 2002 orientada a objetos.
• CobolScript.
• Código . Sistema de programación en paralelo Visual.
• CoffeeScript . Se compila en JavaScript y ofrece una sintaxis más legible (como Scriptol con PHP). Comentario .
• ColdFusion . 2001. Combinación compatible de Java de CFScript y CFML, utilizado para el procesamiento de páginas web dinámicas.
• Comal . 1973.
• CIL. Lenguaje intermedio común.
• Common Lisp .
• Componente Pascal -. Ver Oberon.
• Comit -. Lista o lenguaje procesamiento de cadenas
• Genial.
• Coral66 .
• Maíz.
• Cowsel . Ver POP1.
• CPL (Combinado Programming Language). 1963. Predecesor de BCPL y la propia búsqueda de inspiración en Algol 60.
• Grieta . 2009. Por Google. El lenguaje de scripting por objeto proporcionar la velocidad de programa compilado. La sintaxis viene de C + + con características de Java y Python. A diferencia de Go, cuyo objetivo es compilar todo el tiempo, utiliza LLVM.
• Csh. Ver C Shell.
• Curl .
• Curry .
• Ciclón . 2006. Dialecto de C.

D

• D . 2000. Una versión más simple de C + +, incluye un recolector de basura.
• Databus. Ver PL / B.
• Oscura básica . Idioma de la creación del juego.
• Dardo . 2011. Un lenguaje de navegador diseñado por Google para reemplazar JavaScript agrega clases e interfaces.
• Datalog . En realidad, una herramienta deductiva usando Prolog.
• DCL . Command Language Digital. Scripting PL utiliza en las computadoras digitales.
• Deca . 2011. De alto nivel de idioma para la programación del sistema. Utiliza LLVM.
• Delphi . 1995. Creado por Borland, ahora en el Embarcadero.
• Dibol .
• Disco. 1992.
• DRAKON . 2011. El lenguaje visual para expresar conocimientos para lograr una meta.
• Dylan . 1992. Lenguaje dinámico. A diferencia de Perl, sólo una manera de hacer una cosa. Totalmente orientado a objetos, Lisp-como, que fue creado por Apple para el dispositivo de Newton.

E

• E . Ver también AmigaE.
• Facilidad . Ver Csp y Linda .
• EcmaScript . 1997. La norma oficial para JS.
• Edimburgo IMP. Ver IMP.
• Eiffel . 1986. Diseñado pensando en la seguridad.
• Elan . 1974.
• elásticas .
• Elixir . 2012. Lenguaje funcional Erlang compatible con una sintaxis limpia. Un programa de elixir puede acceder y probar su propio código fuente.
• Emacs Lisp . Secuencias de comandos del editor de código.
• EGL . 2008. Enterprise Generation Language por IBM. Basado en el sistema Cross Producto creado en 1981. Lenguaje de muy alto nivel compilado en otros lenguajes como COBOL, Java, etc
• Epigram. A PL concurrente
• Erlang . 1986, de código abierto en 1998. Idioma Ericsson y también del nombre Agner Krarup Erlang. Funcional, PL y el tiempo de ejecución concurrente.
• . Escapade programación del lado del servidor
• Esterel. INRIA.
• Euclides.
• Euphoria . 1993. Scripting Typed interpretado idioma.
• Euler . Sucesora de Algol 60. Dinámicamente mecanografiado.
• Exec. Ver Rexx.

F

• F .
• F #. Microsoft, en Visual Studio.
• Tela . 2010, Cornell. Basado en Java y Jif, proporciona la seguridad de los datos utilizados y almacenados.
• Factor . 2003.
• Fantom . 2005. C-como correr en JVM y. NET.
• Felix .
• Ferite.
• FL.
• Flow-Matic . 1954.
• Focal .
• Enfoque.
• Foil.
• Forth . 1977. CUARTO. Apilar orientado. Se utiliza para máquinas de mando, incluyendo el arranque de las computadoras.
• Fortran . 1957. Traductor de fórmulas. Estándar Fortran II (58), IV (61), 66, 77 (Procedimiento), 90, 95, 2003 (orientado a objetos).Lenguaje para cálculos científicos. Otros dialectos son S-Fortran, SFtran, QuickTran, LTRTran, HPF, Co-Array Fortran.
• Fortaleza . Diseñado por Sun para la computación de alto rendimiento.
• FP .
• Frink.

T

• T . lenguaje de flujo de datos para el sistema de LabView, para la programación gráfica y en paralelo (y funcional). Uno programas visualmente conectando objetos.
• Gams . Sistema General de modelado algebraico.
• Gml . Game Maker Language.
• Vaya . 2009. Creado por Google, es C y Pascal-like. Es concurrente con un recolector de basura.
• Godiva.
• Goedel.
• Gosu . 2010. Java-como correr en la JVM, proporciona tipos extendidos.
• GPSS .
• Groovy. El lenguaje de scripting para Java.

H

• Halide . 2012. Por el MIT, el lenguaje de procesamiento de imágenes con una sintaxis compacta.
• Hal / S . Lenguaje de programación aeroespacial en tiempo real
• HaScript .
• Haskell . 1990. Lenguaje funcional. Haskell 98 sigue. En la versión 2002 de un lenguaje funcional perezoso. Compiler .
• Heron .
• HLA. Asamblea de Alto Nivel
• Hugo .
• HyperTalk. HyperNext y Supercard son herramientas Hypercard similares.
• H2o.

Yo

• IAL. 1958.
• ICI.
• Icono . 1977-1979.
• IDL . 1977. Interface Definition Language. Una familia de Descriptivos idiomas. Compiler .
• IMP .
• Inform .
• IPL . 1956. Información de Procesamiento del Lenguaje. En primer lugar en el procesamiento de lista, pero sustituido por Lisp.
• Intercal. 1972.
• IO .
• Iswim. 1966.

J

• J . 1990. Es una reanudación de APL.
• Jade .
• Jal .
• Janus . Predecesor de ToonTalk.
• De Java . 1994.
• JavaFX Script . 2008.
• JavaScript . 1996.
• JCL .
• Jif . 2001. Cornell. Java con el control de acceso a la información.
• Únete a Java. Versión aumentada de Java.
• Joss. 1963. Predecesor de paperas.
• Joule .
• Jovial . Jules propia versión de la Internacional algorítmico Lenguaje.
• Alegría.
• JSP . Ver Java.
• JScript . Ver EcmaScript.
• Julia . 2010. Para la programación técnica, utiliza LLVM, rápido en operaciones matemáticas. Un programa puede modificar su propio código. Linux solamente.
• Jython . Ver Python.

K

• K .
• Kid. Ver P-Tac .
• Kiev.
• Kogut .
• Kotlin . 2012. Lenguaje de tipos estáticos para la JVM. Un intento de combinar todas las teorías jug.

L

• LabView .
• Lagoona.
• Lava .
• Leda .
• Lexico .
• Lfyre .
• Limbo . Lenguaje concurrente, para aplicaciones distribuidas sobre el sistema operativo Inferno. Sucesora de Alef.
• Linc.
• LinearML . Lenguaje funcional para la programación paralela.
• Lingo . Varios idiomas: Macromedia Lingo, Lingo Allegro, Linn Lingo, Lingo Lindo.
• Lisaac. Lenguaje orientado a objetos basado en prototipos.
• Lisp . 1958. Procesamiento lista.
• LLJS . 2012. (Low Level JavaScript). Por Mozilla, mecanografiado dialecto de JavaScript cerca de C, y compilado en JS.
• LLVM . 2004. Lenguaje intermedio para compiladores, o máquinas virtuales.
• Logo . 1966-1968. Lisp sin paréntesis. Aprenda programación moviendo una tortuga gráfica. Compiler . (. Net)
• Lua . 1993. (Luna en portugués). Scripting lenguaje C-que se usa principalmente como extensión a C.
• Lucid .
• Lush .
• Lustre.
• LYaPAS.

M

• M . 2008. Lenguaje de modelado de Microsoft.
• M #. 2014. Proyecto del nuevo lenguaje de sistema de Microsoft para competir Go y Rust en su intento de sustituir C.
• M. Ver paperas.
• M4 .
• MAD. Ver IAL, Algol.
• Magma .
• Arce .
• María.
• Mathematica . 1988. Lenguaje de programación que utiliza la notación algebraica para expresiones.
• Matlab .
• Mercury . 1995. Lenguaje de programación lógica funcional. Portado a C, Java, IL (. Net).
• Mesa.
• Metal .
• Metro . 2008. El lenguaje de diseño de Microsoft para Windows Phone, Media Center y los dispositivos móviles. (Link en un archivo legible ppc con LibreOffice).
• Microescritura .
• Imitar.
• Miranda . 1989. Lenguaje funcional, ha inspirado a Haskell.
• Miva .
• Mixal. "Mix Asamblea idioma" para el equipo de Donald Knuth Mix.
• ML.
• Moby .
• Modula-2 . 1980.
• Modula-3 . 1989.
• Mondrian. Haskell-como.
• Mortran . Ver Fortran .
• Moto.
• MSIL. Ver CIL.
• Las paperas . 1967. Sistema multi-Programación Utilidad del Hospital General de Massachusetts. Base de datos de lenguaje orientado.

N

• Napier 88 . Idioma persistente. (Buscar en el sitio).
• Nemerle.
• NESL .
• NetRexx. 1996.
• Neolengua . 2010.
• Newsqueak . 1989. Por Rob Pike en los Laboratorios Bell, que además le harán Go, otra lengua concurrente. Facilita hacer GUIs.
• LGN.
• Nial .
• Niza .
• Nickle .
• Nimrod . 2010. Mejorar la productividad, tiene características meta-programación, compilar en C, JS o binario.
• Noop . 2009. Lenguaje Java como diseñado por Google para alentar sintácticamente buenas prácticas de codificación y los malos hábitos desalentadores. Compilar a código de bytes para la JVM.
• Nu . 2007. Cerca de Lisp y Ruby.
• Nosica .

O

• o: Xml.
• Oberon . 1985-1988. (Luna de Urano). Lenguaje reflexivo. Derivado de Modula-2.
• Objective-C . 1982. C más Smalltalk, que se utiliza en el entorno GNUStep.
• Objetivo Caml . 1996. Derivados de ML lenguaje, funcional e imperativo. Extiende Caml.
• J Objetivo . 2008. Sur-ensemble de JavaScript utilisant La Librairie Ojective-C.
• Objetivo Modula 2 . 2006. Combinación de Objective-C, Smalltalk y Modula 2.
• Obliq .
• OCaml. Ver Objective Caml arriba.
• Occam . (Occam-Pi, Occam-π)
• Octave . Para el cálculo numérico.
• OOC . 2009. C-como, orientado a objetos, compila a C.
• Opal. (Optimized Aplicativo Language). Lenguaje funcional, mónadas introducidas, entonces llamada "comandos".
• OPL . Abrir (o organizador) Lenguaje de Programación.
• OPS5 .
• Orco . Un lenguaje de programación distribuida y concurrente, trabajando a través de los sitios. Puede ser utilizado para scripting Web.
• Oz .

P

• Pascal . 1968-1971. Nombre de un matemático francés.
• PBasic.
• Perl. 1987.
• PHP . 1995. Procesador página inicial de hipertexto Personal. PHP 5 en 2004. PHP 6 en 2007.
• Pico .
• Pike .
• Piloto.
• Pizza .
• PL 11 .
• PL / 0.
• PL / B .
• PL / C. Subconjunto de PL / 1
• PL / I . 1964. Lenguaje de Programación uno.
• PL / M.
• Planner. 1969. Para agregar el procesamiento lógico a un lenguaje procedural. Los subconjuntos se han aplicado.
• Plankalkül . 1946.
• Pliant.
• Pop-11.
• Poplog .
• Portran.
• Pov-Ray .
• Procesamiento . C-como, para la creación de imágenes y animaciones interactivas.
• Profan .
• Prograph .
• Prolog . 1972. La programación lógica, en forma declarativa.
• Proteus .
• P-Tac. Lenguaje paralelo.
• Pure . 2011. Lenguaje funcional interpretado (a través de LLVM) basado en reescritura plazo.
• Purescript . 2011. Lenguaje funcional de tipo estático, compile a JavaScript.
• Python . 1991. Scripting interpretado idioma.

Q

• Q .
• QuakeC. Versión de C para el juego Quake.
• QML . O CVP. Conjunto de los lenguajes de programación de ordenadores cuánticos.
• QML . Lenguaje declarativo para diseñar interfaces de usuario, similar a JavaFX, para Qt .
• Quórum . 2012. Lenguaje orientado a objetos, extensible que tiene como objetivo estar limpio y fácil para los principiantes. Compilar para JVM.

R

• R . 1998. Lenguaje y entorno para computación y gráficos estadísticos. Derivado del lenguaje S está cerca de Scheme.
• R + +. C + + con las normas de creación.
• Rascal. Versión de Pascal para los niños.
• Ratfiv. Versión de Ratfor de un ordenador.
• Ratfor . 1975. Versión de Fortran.
• RC . Shell Rc, Plan9 lenguaje de comandos portado más para Unix.
• Realbasic .
• Rebol . 1997. Expresión relativa Basado objeto de lenguaje.Lenguaje dinámico con numerosos tipos predefinidos. Desde la versión 3.0 es de código abierto (en 2012).
• Rojo . 2011. Similar a Rebol, pero compilado y el código abierto desde el principio.
• Refal . 1968. Funciones recursivas algorítmico Lenguaje.
• Revolución. Versión de HyperTalk.
• RPG . 1960 + Report Generator Programa. Herramienta de consulta ampliado en un lenguaje de programación para IBM cuyo funcionamiento es similar al de eventos. Versiones principales son RPG II, RPG III, RPG/400, RPG IV.
• RPL. Lenguaje para calculadoras similares a Forth.
• Rexx . 1979. REstructured eXecutor extendida. Diseñado para IBM OS scripting pero portado en otras plataformas.
• Rigal.
• Rlab .
• RSL . Robot Scripting Language.
• Rubí . 1995 sigue un "principio de mínima sorpresa", cada cosa debe ser intuitiva. Scripting, multi-paradigma orientado a objetos.
• Rust . 2006. Lenguaje concurrente por Mozilla Labs inspirado de C y la mejora de la seguridad. Alternative to Go.

S

• S. (S-plus) Ver Tinn-R. El Marco de I sostener una implementación.
• S2 .
• Navega . Inteligencia Artificial de Stanford Idioma
• Sam76 . Implementación de Trac.
• SAS. Fortran especializada en informes estadísticos.
• Sather . Lenguaje Eiffel similares.
• Scala . 2004.
• Esquema . 1975.
• Arañazos . 2007. Lenguaje educativo desarrollado por el MIT que consiste en bloques que se montará. El mismo principio se utiliza para la OpenBlockS biblioteca de Java.
• Scriptol . 2001 orientada a objetos y XML orientado. Intérprete y compiladores .
• Sed . Editor de flujo.
• Seed7 . 2005.
• Yo. 1993.
• SETL . 1967-1969. SET El lenguaje ha inspirado ABC, el predecesor de Python, y se transmite la idea de tuplas.
• Código corto. 1949. Precursor de los lenguajes de programación.
• SimsScript. Fortran especializado en simulaciones matemáticas.
• Simmunity. Idioma para Internet basado en APL
• Simula . 1962.
• SISAL . Arroyos y la iteración en una única cesión Idioma
• Pizarra .
• Slip . List Processor simétrica. En realidad una extensión de los lenguajes de programación FORTRAN y otros.
• Smalltalk .
• Snobol . 1962. Snobol 3 (1965), 4 (1966). Basec principalmente en la comparación de patrones.
• SOAP. Simbólico Programa Asamblea óptima, IBM 650 en lenguaje ensamblador.
• Spitbol . Aplicación rápida de SNOBOL. En realidad, una versión compilada de Snobol.
• Snowball . Para representar algoritmos derivados, compilado en C o Java.
• SPARK.
• SP / k. Subconjunto de PL / 1, utilizado para la enseñanza.
• SPL.
• Squeak .
• SR . Sincronización de Recursos
• SSL .
• ML estándar .
• Subtexto .
• SuperCollider .
• SuperX + +. 2001. Lenguaje XML.
• SyncCharts.
• Sinergia / DE .

T

• T . 1.980 + Una versión de Lisp.
• TACL . Tandem Advanced Command Language. Lenguaje de secuencias de comandos utilizada por Hewlett-Packard.
• Tacpol . La implementación de PL / I, fue utilizado por el ejército de EE.UU..
• TADS . Texto Sistema de Desarrollo de Aventura. Un lenguaje para hacer juegos.
• TAL . Transacción Idioma de la aplicación, cruce entre C y Pascal utiliza para ordenadores Tandem.
• Transcripción. Voir Revolución.
• Tcl . 1988. Tool Command Language. Tk es el conjunto de herramientas gráficas.
• TelComp . 1965. Derivado de Joss, el lenguaje conversationnal utilizar en ordenadores PDP hasta 1974. Influenciado paperas.
• Tempo .
• Tinn-r .
• Titanio .
• Lenguaje TI-Basic.Basic similar para calculadoras.
• Tom .
• De Tpu. Lenguaje de programación de scripts para VAX / VMS (no verificado).
• Trac . 1960 +. Reckoning Texto y compilación.
• TTCN-3 . Pruebas y control de pruebas de notación. Anteriormente: "combinada arborescente y tabular la notación".
• Turing. 1982. Pascal-al igual que, derivado de Euclides.
• Tutor. 1965. Lenguaje de programación CAI.
• Letra de imprenta . 2012. Sperset tener JavaScript por Microsoft, con tipos variables, clases y módulos. Compilado de JavaScript. El código abierto bajo licencia Apache.
• TXL. 1988. Derivado de Turing arriba.

U

• Ubercode . 2005. Cruce entre Eiffel y Básica.
• Uncol (Universal Computer Oriented Language). 1958. Lenguaje intermedio para compilaters. Poco utilizado.
• Unicon . Dialecto Extended Unificado de Icon.
• UnrealScript . Juegos de secuencias de comandos.
• UrbiScript . Lenguaje de programación del robot.
• UML . Unified Modeling Language. Lenguaje de programación Visual.

V

• Verilog HDL . Un lenguaje de descripción de hardware.
• VHDL . VHSIC Hardware lenguaje de descripción.
• VDS . DialogScript Visual.
• Virt. Pascal-al igual que con las características del prólogo, para la resolución de problemas de Inteligencia Artificial. Interpreter .
• Visual Basic. 1991.
• . Visual Basic NET.
• VBScript. Guión Edición Visual Basic.

W

• Agua . XML embebido en lenguaje de programación.
• Los espacios en blanco . En realidad, una broma, un lenguaje de programación "esotérico", pero con un intérprete real!
• WinBatch . El lenguaje de scripting para Windows.
• Cableado . Lenguaje similar a C dedicado a la electrónica.

X

• Xotcl . Objeto versión de TCL orientado.
• XPL . 1967. Derivado de PL / I, para la escritura del compilador.
• XL . Implementa la programación concepto.
• Xtend . (2011). Creado por la Fundación Eclipse para facilitar Java, hace mejoras, como la eliminación de un punto y coma, un interruptor de gran alcance como en Scriptol. Compila a código Java.

Y

• YAFL .
• Yorick . Lenguaje para cálculos científicos y simulaciones.

Z

• Notación Z . Especificación visual de programas como UML.
• ZPL .
• ZOPL. (No verificado)
• ZUG. (No verificado)

Los lenguajes de marcas y formatos de datos

• CFML. ColdFusion Markup Language.
• EmotionML . Un dialecto XML para la representación de las emociones, por el W3C ..
• HTML . HyperText Markup Language.
• JSON Patch. Este lenguaje básico es un estándar propuesto por el IETF para las operaciones en un documento JSON.
• PostScript . 1985.
• Buffers Protocolo . Por Google, se convirtió en abierto en 2008.
• RDF . Resource Description Framework.
• SGML. 1969.
• SVG . Gráfico de vector escalable.
• El formato del texto Tex.
• XAML . Extensible Application Markup Language.
• XBL . Extensible Bindings Language. Para crear tu currículum en lenguajes basados ​​en XML.
• Xforms . Interfaz interactiva gráfica web del usuario.
• XHTML. HTML XML.
• XML . eXtensible Markup Language.
• XUL . -Interfaz de usuario basada en XML de idioma.

Consulta o base de datos orientada a idiomas

• Aubit-4GL . Ver Informix.
• D4 o Dataphor. Basado en Tutorial D.
• Dataflex . 1980. Lenguaje de programación de base de datos.
• dBase . lenguaje de programación.
• HyperTalk. 1987. Idioma Tarjeta para Apple.
• Informix-4GL . 4GL significa para el lenguaje especializado de cuarta generación. Informix está especializada en bases de datos e informes.
• PL / SQL . Extensión SQL.
• SQL . 1987. Structured Query Language.
• Tutorial D.
• Visual FoxPro . Derivado de dBase.
• xBaseScript . (XbScript) scripts de base de datos Clipper.

Hola mundo Lenguaje de programacion

A

4GL

message "Hello, World!" with style = popup;

Abap

WRITE 'Hello, World!'.

Abc

WRITE "Hello, World!"

ActionScript

trace("Hello, World!");

Graphical version:

this.createTextField("hello_txt",0,10,10,100,20);
this.hello_txt.text="Hello, World!";

Ada

with TEXT_IO;

procedure HELLO is
begin
 TEXT_IO.PUT_LINE ("Hello, World!");
end HELLO;

Algol 60

'BEGIN'
 'COMMENT' In Algol 60;
 OUTPUT(4,'(''('Hello World!')',/')')
'END

Algol 68

BEGIN
print(("Hello, World!", newline))
END

Using the short form of begin and end:

( print("Hello, World!") )

Alma-0

Hello, World!

AmigaE

PROC main()
 WriteF('Hello, World!');
ENDPROC

Apl

'Hello, World!'

AppleScript

return "Hello, World!"

or:

-- "Hello World!"

Graphical:

display dialog "Hello World!" buttons {"OK"} default button 1

Ascii

In hexadecimal notation (0D = carriage return, 0A = newline):

48 65 6C 6C 6F 2C 20 77 6F 72 6C 64 21 0D 0A

Asp

<%
Response.Write("Hello, World!")
%>

or:

<%="Hello, World!" %>

Asp.Net

Response.Write("Hello, World!")

AspectJ

public aspect HelloWorld 
{
 pointcut mainCall() : call(public static void *.main(String[] args));
 before() : mainCall() 
 {
 System.out.println( "Hello World!" );
 }
}

Assembly language

6502 assembler

MSG: .ASCIIZ "Hello, World!"
START: LDX #0
LOOP: LDA MSG,X ; load character
 JSR $FFD2 ; output to current output device
 INX
 BNE @LOOP 
 RTS

Intel x86, Dos, Tasm

MODEL SMALL
IDEAL
STACK 100H

DATASEG
 MSG DB 'Hello, World!', 13, '$'

CODESEG
Start:
 MOV AX, @data
 MOV DS, AX
 MOV DX, OFFSET MSG
 MOV AH, 09H ; output ascii string
 INT 21H
 MOV AX, 4C00H
 INT 21H
 END Start

Intel x86, Linux

SECTION .data
msg:
 db "Hello, World!\n"
 len equ $ - msg
SECTION .text
 global start
start:
 mov edx,len
 mov ecx,msg
 mov ebx,1
 mov eax,4
 int 0x80
 mov ebx,0
 mov eax,1
 int 0x80

Assembler 68000:

move.l #helloworld,-(A7)
 move #9,-(A7)
 trap #1
 addq.l #6,A7
 move #0,-(A7)
 trap #1
helloworld:
 dc.b "Hello World!",$0d,$0a,0

Arm, Risc OS:

.program 
 ADR R0,message
 SWI "OS_Write0"
 SWI "OS_Exit"
.message 
 DCS "Hello, World!"
 DCB 0
 ALIGN

or the even smaller version (from qUE):

 SWI"OS_WriteS":EQUS"Hello, World!":EQUB0:ALIGN:MOVPC,R14

Risc processor and Mips architecture

 .data
msg: .asciiz "Hello, World!"
 .align 2
 .text
 .globl main 
main:
 la $a0,msg
 li $v0,4
 syscall
 jr $ra

AutoHotkey

MsgBox, "Hello, World!"

Autoit

MsgBox(1,'','Hello, World!')

Avenue - Scripting language for ArcView GIS

MsgBox("Hello, World!","aTitle")

Awk

# Hello
BEGIN { print "Hello, World!" }

B

B

/* Hello */

main() 
{
 extern a, b, c;
 putchar (a); putchar (b); putchar (c); putchar ('!*n');
}

a 'hell' ;
b 'o, w' ;
c 'orld' ;

Bash

#!/bin/sh
echo "Hello, World!"

Basic

General

ANSI/ISO-compliant BASIC implementation. The "END" statement is optional in many implementations of BASIC.

10 PRINT "Hello, World!"
20 END

Immediate mode.

PRINT "Hello, World!"
? "Hello, World!"

Later implementations of BASIC. Again, the "END" statement is optional in many BASICs.

PRINT "Hello, World!"
END

DarkBasic

PRINT "HELLO WORLD"
TEXT 0,0,"Hello, World!"
WAIT KEY

PBasic

DEBUG "Hello, World!", CR

or, the typical microcontroller Hello World program equivalent with the only output device present being a light-emitting diode (LED) (in this case attached to the seventh output pin):

DO
 HIGH 7 'Make the 7th pin go high (turn the LED on)
 PAUSE 500 'Sleep for half a second
 LOW 7 ' Make the 7th pin go low (turn the LED off)
 PAUSE 500 'Sleep for half a second
LOOP
END

StarOffice/OpenOffice Basic

sub main
 print "Hello, World!"
end sub

Visual Basic

Sub Main()
 Print "Hello, World!"
End Sub

Visual Basic .Net

Module HelloWorldApp
 Sub Main()
 System.Console.WriteLine("Hello, World!")
 End Sub
End Module

or:,

Class HelloWorldApp
 Shared Sub Main()
 System.Console.WriteLine("Hello, World!")
 End Sub
End Class

Bcpl

// Hello

GET "LIBHDR"

LET START () BE
$(
 WRITES ("Hello, World!*N")
$)

Beta

{ *** Hello ***}
(#
 do
 'Hello World!'->putLine
#)

Bliss

%TITLE 'HELLO_WORLD'
MODULE HELLO_WORLD (IDENT='V1.0', MAIN=HELLO_WORLD,
 ADDRESSING_MODE (EXTERNAL=GENERAL)) =
BEGIN

 LIBRARY 'SYS$LIBRARY:STARLET';

 EXTERNAL ROUTINE
 LIB$PUT_OUTPUT;

GLOBAL ROUTINE HELLO_WORLD =
BEGIN
 LIB$PUT_OUTPUT(%ASCID %STRING('Hello, World!'))
END;

END
ELUDOM

Boo

print "Hello, World!"

C

C (ANSI)

#include <stdio.h>

/* Hello */
int main(void)
{
 printf("Hello, World!");
 return 0;
}

C Windows

#include <windows.h>
int WinMain( HINSTANCE hInstance, HINSTANCE hPrevInstance, LPWSTR lpCmdLine, int nCmdShow )
{
  MessageBox( NULL, "Hello World!\n", "", MB_OK );
  return 0;
}
</windows.h>

C#

using System;
class HelloWorld
{
 static void Main()
 {
 System.Console.WriteLine("Hello, World!");
 }
}

C++ (ISO)

#include <iostream>

int main()
{
 std::cout << "Hello, World!\n";
}

C++ / Cli

int main()
{
 System::Console::WriteLine("Hello, World!");
}

C++ Managed (.Net)

#using <mscorlib.dll>

using namespace System;

int wmain()
{
 Console::WriteLine("Hello, World!");
}

Caml light

(* Hello World *)

let hello =
 print_string "Hello World!";
;;

Cil

.method public static void Main() cil managed
{
 .entrypoint
 .maxstack 8
 ldstr "Hello, World!"
 call void [mscorlib]System.Console::WriteLine(string)
 ret
}

Clean

module hello

Start = "Hello, World!"

Clist

PROC 0
WRITE Hello, World!

Clipper

? "Hello, World!"

Clu

start_up = proc ()
 po: stream := stream$primary_output ()
 stream$putl (po, "Hello, World!")
 end start_up

Cobol

IDENTIFICATION DIVISION.
PROGRAM-ID. HELLO-WORLD.

ENVIRONMENT DIVISION.

DATA DIVISION.

PROCEDURE DIVISION.
DISPLAY "Hello, World!".
STOP RUN.

Cocoa or GnuStep (Objective C)

#import <Cocoa/Cocoa.h>
@interface hello : NSObject {
}
@end

@implementation hello

-(void)awakeFromNib
{ 
 NSRunAlertPanel(@"Message from your Computer", @"Hello, World!", @"Hi!",
 nil, nil);
}

@end

CoffeeScript

alert "Hello World!"

ColdFusion

<cfoutput>Hello, World!</cfoutput>

Comal

PRINT "Hello, World!"

Curl

{curl 3.0, 4.0 applet}
{curl-file-attributes character-encoding = "utf-8"}

Hello, World!

D

D

import std.stdio ;
void main () 
{
  writef("Hello, World!");
}

D++

function main()
{
  screenput "Hello, World!";
}

Dart

main() 
{
  print('Hello, World!');
}

Dataflex

/tela
Hello world
/*
clearscreen
page tela

dBase

* Hello World in dBase IV
? "Hello World!"

Dcl batch

$ write sys$output "Hello, World!"

Delphi, Kylix

program Hello_World;
uses 
 Windows;

begin
 ShowMessage("Hello, World!");
end.

Doll

this::operator()
{
 import system.cstdio;
 puts("Hello, World!");
}

Dylan

module: hello

format-out("Hello, World!\n");

E

Ed and Ex (Ed extended)

a
hello World!
.
p

EGL

Program Hello
   const MYVAR string = "Hello World!";
   function main()
      SysLib.writeStdOut(MYVAR);
   end     
 end

Eiffel

class HELLO_WORLD

creation
 make
feature
 make is
 local
 io:BASIC_IO
 do
 !!io
 io.put_string("%N Hello, World!")
 end -- make
end -- class HELLO_WORLD

Elan

(* Elan *)
putline ("Hello World!");

Erlang

-module(hello).
-export([hello_world/0]).

hello_world() -> io:fwrite("Hello, World!\n").

Euphoria

puts(1, "Hello, World!")

F

F#

print_endline "Hello, World!"

Factor

"Hello, World!" print

filePro

 @once:
 mesgbox "Hello, World!" ; exit

Focal

type "Hello, World!",!

Focus

-TYPE Hello world

Forth

: HELLO ( -- ) ." Hello, World!" CR ;
HELLO

Fortran

 PROGRAM HELLO
 PRINT *, 'Hello, World!'
 END

Fril

 ?((pp "Hello, World!"))

Frink

println["Hello, World!"]

G

Gambas

PUBLIC SUB Main()
 Print "Hello, World!"
END

Graphical:

PUBLIC SUB Main()
 Message.Info("Hello, World!")
END

Go

package main
import fmt "fmt"

func main() 
{
   fmt.Printf("Hello, World!\n");
}

Groovy

println "Hello, World"

Gtk+ in C++

#include <iostream>
#include <gtkmm/main.h>
#include <gtkmm/button.h>
#include <gtkmm/window.h>
using namespace std;

class HelloWorld : public Gtk::Window {
public:
 HelloWorld();
 virtual ~HelloWorld();
protected:
 Gtk::Button m_button;
 virtual void on_button_clicked();
};

HelloWorld::HelloWorld()
: m_button("Hello, World!") {
 set_border_width(10);
 m_button.signal_clicked().connect(SigC::slot(*this,
 &HelloWorld::on_button_clicked));
 add(m_button);
 m_button.show();
}

HelloWorld::~HelloWorld() {}

void HelloWorld::on_button_clicked() {
 cout << "Hello, World!" << endl;
}

int main (int argc, char *argv[]) {
 Gtk::Main kit(argc, argv);
 HelloWorld helloworld;
 Gtk::Main::run(helloworld);
 return 0;
}

Gtk# in C#

using Gtk;
using GtkSharp;
using System;

class Hello {
 static void Main()
 {
   Application.Init ();

   Window window = new Window("");
   window.DeleteEvent += cls_evn;
   Button close = new Button ("Hello world");
   close.Clicked += new EventHandler(cls_evn);

   window.Add(close);
   window.ShowAll();

   Application.Run ();
 }
 static void cls_evn(object obj, EventArgs args)
 {
   Application.Quit();
 }
}

H

Haskell

module Main (main) where

main = putStrLn "Hello, World!"

Heron

program HelloWorld;
functions {
 _main() {
 print_string("Hello, World!");
 }
}
end

HLA (High Level Assembly)

program helloWorld;
#include("stdlib.hhf")
begin helloWorld;

 stdout.put( "Hello World" nl );

end helloWorld;

HP-41, HP-42S

Hewlett-Packard RPN-based alphanumeric engineering calculators.

01 LBLTHELLO
02 THELLO, WORLD
03 PROMPT

HTML

<html>
<body>
 Hello, World!
</body>
</html>

HTML 4.01 Strict

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Strict//EN" "http://www.w3.org/TR/html4/strict.dtd">
<html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
 <title>Hello, World!</title>
 </head>
 <body>
 <p>Hello, World!</p>
 </body>
</html>

HyperTalk

Apple HyperCard's scripting programming language.

put "Hello, World!"

or

Answer "Hello, World!"

I

Icon

# In Icon
procedure main()
 write("Hello world")
end

IDL

print,"Hello World!"

Inform

[ Main;
 "Hello, World!";
];

Intercal

 IN INTERCAL 
 HELLO WORLD

Io

"Hello, World!" print

or

write("Hello, World!\n")

Iptscrae

ON ENTER {
 "Hello, " "World!" & SAY
}

J

J

'Hello world'

Java

public class HelloWorld {
 public static void main(String[] args) {
 System.out.println("Hello, World!");
 }
}

Java byte-code

Disassembler output of javap -c HelloWorld.

public class HelloWorld extends java.lang.Object{
public HelloWorld();
 Code:
 0: aload_0
 1: invokespecial #1; //Method java/lang/Object."<init>":()V
 4: return
public static void main(java.lang.String[]);
 Code:
 0: getstatic #2; //Field java/lang/System.out:Ljava/io/PrintStream;
 3: ldc #3; //String Hello, World!
 5: invokevirtual #4; //Method java/io/PrintStream.println:(Ljava/lang/String;)V
 8: return
}

Java Swing

import javax.swing.JOptionPane;

public class Hello 
{
 public static void main(String[] args) 
 {
 JOptionPane.showMessageDialog(null, "Hello, World!");
 }
}

Java SWT

import org.eclipse.swt.SWT;
import org.eclipse.swt.layout.RowLayout;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.swt.widgets.Label;

public class SWTHello {
 public static void main (String [] args) {
 Display display = new Display ();
 final Shell shell = new Shell(display);
 RowLayout layout = new RowLayout();
 layout.justify = true;
 layout.pack = true;
 shell.setLayout(layout);
 shell.setText("Hello, World!");
 Label label = new Label(shell, SWT.CENTER);
 label.setText("Hello, World!");
 shell.pack();
 shell.open ();
 while (!shell.isDisposed ()) {
 if (!display.readAndDispatch ()) display.sleep ();
 }
 display.dispose ();
 }
}

Java applet

Java applets work in conjunction with HTML files.

<HTML>
<HEAD>
<TITLE>Hello world</TITLE>
</HEAD>
<BODY>

HelloWorld Program says:

<APPLET CODE="HelloWorld.class" WIDTH=600 HEIGHT=100>
</APPLET>

</BODY>
</HTML>

import java.applet.*;
import java.awt.*;

public class HelloWorld extends Applet {
 public void paint(Graphics g) {
 g.drawString("Hello, World!", 100, 50);
 }
}

JavaFX Script (F3)

var win = new Frame();
win.title = "Hello World!";
win.width = 400;
var label = new Label();
label.text = "Hello World!";
win.content = label;
win.visible = true;

Visual version:

Stage {   
    title: "Hello World!"    
    width: 320    
    height: 240    
    visible: true  
}   

JavaScript

<script language="JavaScript">
    document.write('Hello, World!');
</script>

or with an alert

alert('Hello, World!');

or

<script type="text/javascript">
function helloWorld()
{
 alert("Hello, World!");
}
</script>

<a href="#" onclick="helloWorld(); return false;">Hello World Example</a>

or

<a href="#" onclick="alert('Hello, World!'); return false;">Hello World Example
</a>

K

K

`0:"Hello world\n"

Kogut

WriteLine "Hello, World!"

L

LaTeX

\documentclass{article}
\begin{document}
 Hello, World!
\end{document}

Lisaac

section HEADER
 + name := HELLO_WORLD;
 - category := MACRO;
section INHERIT
 - parent_object:OBJECT := OBJECT;
section PUBLIC
 - make <-
 ( 
 "Hello World !\n".print;
 );

Lisp

Lisp has many dialects that have appeared over its almost fifty-year history.

Common Lisp

(format t "Hello World!~%")

or

(write-line "Hello World!")

or merely:

 "Hello World!"

Scheme

(display "Hello, World!")

Emacs Lisp

 (print "Hello, World!")

AutoLisp

 (print "Hello, World!")

XLisp

 (print "Hello, World!")

Logo

print [Hello World!]

or

pr [Hello World!]

Lua

print "Hello, World!"

M

M4

Hello, World!

Macsyma, Maxima

print("Hello, World!")$

Maple

>> print("Hello, World!");

Mathematica

(* Hello World in Mathematica *)
Print["Hello world"]

Matlab

disp('Hello world')

Maude

fmod HELLOWORLD is
protecting STRING .
 op helloworld : -> String .
 eq helloworld = "Hello, World." .
endfm
red helloworld .

Max

max v2;
#N vpatcher 10 59 610 459;
#P message 33 93 63 196617 Hello World!;
#P newex 33 73 45 196617 loadbang;
#P newex 33 111 31 196617 print;
#P connect 1 0 2 0;
#P connect 2 0 0 0;
#P pop;

mIrc Script

echo Hello World

Model 204

BEGIN
PRINT 'Hello, World!'
END

Modula-2

MODULE Hello;

FROM InOut IMPORT WriteLn, WriteString;

BEGIN
 WriteString ("Hello, World!");
 WriteLn
END Hello.

(* Modula-2 R10 *)  

MODULE Hello; 
IMPORT PervasiveIO;
BEGIN
   WRITE("Hello, World!\n");
END Hello. 

Moo

notify(player, "Hello, World!");

Ms-Dos batch

The @ symbol is optional and prevents the system from displaying the command before executing it.

@echo Hello, World!

Muf

: main
 me @ "Hello, World!" notify
;

Mumps

W "Hello, World!"

N

Natural

WRITE "Hello, World!"
END

Nemerle

System.Console.WriteLine("Hello, World!");

NewtonScript

baseview :=
 {viewBounds: {left: -3, top: 71, right: 138, bottom: 137},
 viewFlags: 581,
 declareSelf: 'base,
 _proto: protoFloatNGo,
 debug: "baseview"
 };

textview := * child of baseview *
 {text: "Hello World!",
 viewBounds: {left: 33, top: 24, right: 113, bottom: 46},
 viewFlags: 579,
 _proto: protoStaticText,
 debug: "textview"
 };

Nice

void main(String[] args)
{ 
 println("hello world"); 
}

O

Oberon

MODULE Hello;
 IMPORT Out;
BEGIN
 Out.String("Hello World!");
 Out.Ln
END Hello.

Objective C

Functional C Version

#import <stdio.h>

int main() {
 printf( "Hello, World!\n" );
 return 0;
}

Object-Oriented C Version

#import <stdio.h>

//An object-oriented version.
@interface Hello : Object
{
 const char str[] = "Hello world";
}
- (id) hello (void);
@end

@implementation Hello
- (id) hello (void)
{
 printf("%s\n", str);
}
@end

int main(void)
{
 Hello *h = [Hello new];
 [h hello];

 [h free];
 return 0;
}

OpenStep/Cocoa Version

#import <Foundation/Foundation.h>

int main (int argc, const char * argv[])
{
 NSLog(@"Hello, World!");
 return 0;
}

OCaml

print_endline "Hello World!"

Occam

#USE "course.lib"

PROC hello.world(CHAN OF BYTE screen!)
 out.string("Hello World!*n", 0, screen!)
:

Octave

printf("Hello World\n");

Opl

PROC hello:
 PRINT "Hello, world"
ENDP

Ops5

(object-class request
 ^action)

(startup
 (strategy MEA)
 (make request ^action hello)
)

(rule hello
 (request ^action hello)
 (write |Hello World!| (crlf))
)

Ops83

module hello (main)
{ procedure main( )
 {
 write() |Hello, World!|, '\n';
 };
};

Oz

{Browse 'Hello World!'} 

P

Parrot assembly language

print "Hello, World!\n"
end

Pascal

program hello;

begin
writeln('Hello, World!');
end.

Pdf

%PDF-1.0
1 0 obj
<<
/Type /Catalog
/Pages 3 0 R
/Outlines 2 0 R
>>
endobj
2 0 obj
<<
/Type /Outlines
/Count 0
>>
endobj
3 0 obj
<<
/Type /Pages
/Count 1
/Kids [4 0 R]
>>
endobj
4 0 obj
<<
/Type /Page
/Parent 3 0 R
/Resources << /Font << /F1 7 0 R >>/ProcSet 6 0 R
>>
/MediaBox [0 0 612 792]
/Contents 5 0 R
>>
endobj
5 0 obj
<< /Length 44 >>
stream
BT
/F1 24 Tf
100 100 Td (Hello World) Tj
ET
endstream
endobj
6 0 obj
[/PDF /Text]
endobj
7 0 obj
<<
/Type /Font
/Subtype /Type1
/Name /F1
/BaseFont /Helvetica
/Encoding /MacRomanEncoding
>>
endobj
xref
0 8
0000000000 65535 f
0000000009 00000 n
0000000074 00000 n
0000000120 00000 n
0000000179 00000 n
0000000322 00000 n
0000000415 00000 n
0000000445 00000 n
trailer
<<
/Size 8
/Root 1 0 R
>>
startxref
553
%%EOF

Perl

# Hello
print "Hello, World!\n";

Perl 6

say "Hello world";

PHP

<?php
 echo 'Hello, World!';
?>

or

<?php
 print 'Hello, World!' . PHP_EOL;
?>

or

<?='Hello, World!'?>

PHP-GTK

<?php
$wnd = new GtkWindow();
$wnd->set_title('Hello');
$wnd->connect_simple('destroy', array('gtk', 'main_quit'));
$lblHello = new GtkLabel("Hello world!'");
$wnd->add($lblHello);
$wnd->show_all();
Gtk::main();
?>

Pike

int main() {
 write("Hello, World!\n");
 return 0;
}

Pilot

T:Hello, World!

Pl/Sql

-- start anonymous block
set serveroutput on size 10000000;
begin
 dbms_output.enable(1000000);
 dbms_output.put_line('Hello World!'); 
end;
-- end anonymous block

Pl/I

Test: proc options(main) reorder;
 put skip edit('Hello, World!') (a);
end Test;

Pop-11

'Hello world' =>

PostScript

% Displays on console.
(Hello World!) =

%!
% Displays as page output.
/Courier findfont
24 scalefont
setfont
100 100 moveto
(Hello World!) show
showpage

Pov-Ray

#include "colors.inc"
camera {
 location <3, 1, -10>
 look_at <3,0,0>
}
light_source { <500,500,-1000> White }
text {
 ttf "timrom.ttf" "Hello World!" 1, 0
 pigment { White }
}

Processing

println("Hello, World!");

Profan

' Hello in Profan 
cls
print "Hello World!"
waitkey

Progress

message "Hello World" view-as alert-box.

Prolog

:- write('Hello world'),nl.

Protocol Buffers

message hello
{
  required string data = 1 [default="Hello World!"];
} 

PureBasic

; In PureBasic console
OpenConsole()
 ConsoleTitle ("Hello World!")
 PrintN ("Hello World!")
CloseConsole()

Python 2

print "Hello, World!" 

Python 3

print("Hello, World!") 

Q

QML

Text {          
     text: "Hello World"          
} 

Qt toolkit (C++)

#include <QApplication>
#include <QLabel>

int main(int argc, char *argv[])
{
  QApplication app(argc, argv);
  QLabel salut("Hello World!");
  salut.show();
  return app.exec();
}

QuakeC

bprint("Hello World\n");

QuickBasic

REM Hello World in QuickBASIC
PRINT "Hello World!"
END

R

R

cat("Hello world\n")

Ratfor

print *, 'hello, world'
end

RealBasic

' Hello
msgBox "Hello World!"

Rebol

print "Hello, World!"

Refal

$ENTRY GO{=<Prout 'Hello, World!'>;}

Rexx, ARexx, NetRexx, and Object REXX

say "Hello, World!"

or, Windows:

call RxFuncAdd 'SysLoadFuncs', 'RexxUtil', 'SysLoadFuncs'
call SysLoadFuncs
call RxMessageBox 'Hello World!', 'Hello World Window', 'OK', 'EXCLAMATION'
exit

Rpg

Free-Form Syntax

 /FREE
 DSPLY 'Hello, World!';
 *InLR = *On;
 /END-FREE 

Traditional Syntax

 d TestMessage 
 c Const( 'Hello, World!' )
 c TestMessage DSPLY
 c EVAL *InLR = *On

Rpg Code

Message Window

mwin("Hello, World!")
wait()

On Screen Text

text(1,1"Hello, World!")
wait()

RPL (HP calculators)

<<
     CLLCD
     "Hello, World!" 1 DISP
     0 WAIT
     DROP
   >>

Rsl

[Hello World!];

Rtf

{\rtf1\ansi\deff0
{\fonttbl {\f0 Courier New;}}
\f0\fs20 Hello, World!
}

Ruby

puts "Hello, World!"

Rust

io::println("hello?");

S

S

cat("Hello world\n")

Sas

data _null_;
put 'Hello, World!';
run;

Sather

class HELLO_WORLD is
 main is 
 #OUT+"Hello world\n"; 
 end; 
end;

Scala

object HelloWorld with Application {
 Console.println("Hello, World!");
}

Scriptol

 print "Hello World!"

sed

sed -ne '1s/.*/Hello, World!/p'

Seed7

$ include "seed7_05.s7i";

const proc: main is func
 begin
 writeln("Hello, World!");
 end func;

Self

'Hello, World!' print.

Setl

-- Hello in Setl2

procedure Hello();
 print "Hello World!";
end Hello;

Scheme

 (display "Hello world!")
 (newline)

Simula

Begin
 OutText("Hello, World!");
 OutImage;
End

Smalltalk

Transcript show: 'Hello, World!'; cr

Graphical:

('Hello, World!' asMorph openInWindow) submorphs second color: Color black

Smil

<!-- Hello World in SMIL -->
<smil>
 <head>
 <layout>
 <root-layout width="300" height="160" background-color="white"/>
 <region id="text_region" left="115" top="60"/>
 </layout>
 </head>
 <body>
 <text src="data:,Hello%20World!" region="text_region">
 <param name="fontFace" value="Arial"/>
 </text>
 </body>
</smil>

Sml

print "Hello, World!\n";

Snobol

 OUTPUT = "Hello, World!"
END

Span

class Hello {
 static public main: args {
 Console << "Hello, World!\n";
 }
}

Spark

with Spark_IO;
--# inherit Spark_IO;
--# main_program;

procedure Hello_World
--# global in out Spark_IO.Outputs;
--# derives Spark_IO.Outputs from Spark_IO.Outputs;
is
begin
 Spark_IO.Put_Line (Spark_IO.Standard_Output, "Hello, World!", 0);
end Hello_World;

Spitbol

 OUTPUT = "Hello, World!"
END

Spss Syntax

ECHO "Hello, World!".

Sql

CREATE TABLE message (text char(15));
INSERT INTO message (text) VALUES ('Hello, World!');
SELECT text FROM message;
DROP TABLE message;

MySQL or PostgreSQL:

SELECT 'Hello, World!';

Starlet

RACINE: HELLO_WORLD.

NOTIONS:
HELLO_WORLD : ecrire("Hello, World!").

SuperCollider

"Hello World".postln;

Svg

<?xml version="1.0" encoding="utf-8" standalone="no"?>
<svg width="240px" height="100px" viewBox="0 0 240 100" 
     xmlns="http://www.w3.org/2000/svg">
 <title>Hello World</title>
 <g>
 <text x="20" y="50">Hello World</text>
 </g>
</svg>

T

Tacl

?TACL HELLO
#OUTPUT Hello, World!

Tcl

puts "Hello, World!"

Teco

!Hello in TECO
FTHello World$

TeX

Hello world
\bye

Ti-Basic

10 REM Hello World in TI BASIC
20 REM for the TI99 series computer
100 CALL CLEAR
110 PRINT "HELLO WORLD"
120 GOTO 120

Tk

label .l -text "Hello World!"
pack .l

Turing

put "Hello, World!"

U

Unix shell

echo 'Hello, World!'

or using an inline 'here document'

cat <<'DELIM'
Hello, World!
DELIM

or

printf '%s' $'Hello, World!\n'

or for a curses interface:

dialog --msgbox 'Hello, World!' 0 0

UnrealScript

class HelloHUD extends HudBase;

simulated function DrawHudPassC (Canvas C)
{
 C.SetPos( 0.50*C.ClipX , 0.50*C.ClipY);
 C.DrawText("Hello World!");
}

defaultproperties
{
}

V

Verilog

module main;

 initial
 begin
 $display("Hello, World");
 $finish ;
 end

 endmodule

VHDL

use std.textio.all;

ENTITY hello IS
END ENTITY hello;

ARCHITECTURE Scriptol OF hello IS
 CONSTANT message : string := "hello world";
BEGIN
 PROCESS
 variable L: line; 
 BEGIN
 write(L, message);
 writeline(output, L);
 wait;
 END PROCESS;
END ARCHITECTURE Scriptol;

Visual Basic .Net 2003

If the code is entered as part of a Form subclass:

Private Sub frmForm_Load(ByVal sender As Object, ByVal e As System.EventArgs) Handles MyBase.Load
 MessageBox.Show("Hello World!", "HELLO WORLD") 
 Me.Close() 
End Sub

Traditional Visual Basic code:

Public Class MyApplication
 Shared Sub Main()
 MessageBox.Show("Hello World!", "HELLO WORLD")
 End Sub
End Class

Visual DialogScript

info Hello world!

Visual Prolog console program

#include @"pfc\console\console.ph"

goal
 console::init(),
 stdio::write("Hello, World!").

W

Windows api (in C)

#include <windows.h>
int WINAPI WinMain(HINSTANCE hInst, HINSTANCE hPrevInstance, LPSTR lpCmdLine,
int nCmdShow)
{
 MessageBox(NULL, "Hello, World!", "", MB_OK);
 return 0;
}

Vms

$ WRITE SYS$OUTPUT "Hello World!"

Vmrl

Shape
{
 geometry Text
 {string "Hello World!"}
}

Wscript

WScript.Echo("Hello World!"); 

X

X++

class classHello
{
}

static void main(args Args)
{
 dialog dialog;
 dialog = new dialog();
 dialog.addText("Hello World!");
 dialog.run();
}

XAML/WPF

<Page xmlns="http://schemas.microsoft.com/winfx/avalon/2005">
 <TextBlock>Hello, World!</TextBlock>
</Page>

XHTML 1.1

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN" "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en">
 <head>
 <title>Hello</title>
 </head>
 <body>
 <p>Hello, World!</p>
 </body>
</html>

XML

<?xml version="1.0" encoding="UTF-8"?>
<?xml-stylesheet type="text/xsl" href="HelloWorld.xsl" ?>
<!-- Hello in XML -->
<text>
   <string>Hello, World!</string>
</text>

XQuery

(: Hello with XQuery :)
let $i := "Hello World!"
return $i

XSLT

Simplest code:

<xsl:template match="/">
 <xsl:text>Hello, World!</xsl:text>
</xsl:template>

Generate HTML:

 <xsl:template match="/">
 <html>
 <body>
 <h1>Hello, World!</h1>
 </body>
 </html>
 </xsl:template>

XUL

<?xml-stylesheet href="chrome://global/skin" type="text/css" ?>
<window xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul"
 align="center" pack="center" flex="1">
 <description>Hello, World!</description>
</window>

---

•