प्रोग्रामन भाषाओं की सूची (वर्गानुसार)

अर्रे भाषाएँ (Array languages) 
 A+
 Analytica
 APL
 Chapel
 F
 F-Script
 FISh
 Fortran 90 and later versions
 Fortress
 IDL
 J
 K
 MATLAB
 Octave
 NESL
 Nial
 PDL
 R
 S-Lang
 SAC
 X10
 ZPL

 ऐस्पेक्ट-ओरिएन्टेड भाषाएँ (Aspect-oriented languages) 

 AspectC++
 AspectJ
 AspectLua (a Lua extension)
 CaesarJ
 Compose*
 ObjectTeams
 E

 असेम्बली भाषाएँ (Assembly languages) 
 ASEM-51
  (AvtoKod "Inzhener", "Engineer's Autocode" for Minsk family of computers)
 ASCENT (ASsembler for CENTral Processor Unit of Control Data Corporation computer systems pre-COMPASS)
 ASPER (ASsembler for PERipheral Processor Units of Control Data Corporation computer systems pre-COMPASS)
 BAL (Basic AssembLer) - for IBM System/360 and later mainframe systems
 C-- (name used by a few languages that bring C language closer to Assembly)
 COMPASS (COMPrehensive ASSembler)
 Emu8086  (x86 assembler and Intel's 8086 microprocessor emulator)
 EDTASM (Microsoft editor/assembler for Motorola 6809 on the Color Computer)
 FAP (Fortran Assembly Program, for IBM 709, 7090, 7094 mainframes)
 FASM (Flat Assembler; IA-32, IA-64)
 GAS (GNU Assembler)
 HLA (High Level Assembly)
 HLASM (High Level Assembler, for mainframes)
 LC-3
 Linoleum (for cross-platform use)
 MACRO-11 (for DEC PDP-11)
 MACRO-20 (for DEC DECSYSTEM-20)
 MACRO-32 (for DEC VAX)
 MASM (Microsoft Macro Assembler)
 MI (Machine Interface, compile-time intermediate language)
 MIPS (for MIPS architecture) Microprocessor without Interlocked Pipeline Stages
 Motorola 68k Assembly (for Motorola 68000 family) of CPUs
 NASM (Netwide Assembler)
 NEAT (National's Electronic Autocoder Technique), for NCR computers, evolved into NEAT/3 (comment: NEAT/3 was more an RPG clone than an assembler type language)
 PAL-III (for DEC PDP-8)
 PASM (for Parrot virtual machine)
 RosAsm (32-bit Assembler; The Bottom Up Assembler) 
 SC123 (for educational computer developed at CSU)
 Sphinx C-- (mixes Assembly commands with C-like structures)
 SSK (Sistema Simvolicheskogo Kodirovaniya, or "System of symbolic coding") for Minsk family of computers
 TASM (Turbo Assembler, Borland)
 Yasm (Rewrite of NASM)

 लेखन भाषाएँ (Authoring languages) 
 Bigwig (web design language)
 Coursewriter
 PILOT
 TUTOR

 कमाण्ड लाइन इंटरफेस युक्त भाषाएँ (Command line interface languages) 
 4DOS (extended command-line shell for IBM PCs)
 .bat (Windows batch file language as understood by COMMAND.COM and Command Prompt)
 Windows PowerShell (Microsoft .NET-based CLI)
 CHAIN (Datapoint)
 CLIST (MVS Command List)
 DCL DIGITAL Command Language - standard CLI language for VMS (DEC, Compaq, HP)
 DOS batch language (standard CLI/batch language for the IBM PC running DR-DOS, MS-DOS, or PC-DOS before Windows)
 EA_QB_Command
 CMS EXEC
 EXEC 2
 JCL (punch card-oriented batch control language for IBM System/360 family mainframes)
 sh (the standard UNIX shell, written by Stephen R. Bourne)
 csh (C-like shell from Bill Joy at UC Berkeley)
 Ch (C-compatible shell)
 tcsh (a UNIX shell)
 bash (the Bourne-Again shell from GNU/FSF)
 ksh (a standard UNIX shell, written by David Korn)
 zsh (a UNIX shell)
 Rc (command-line shell for Plan 9)
 Es shell (shell based on Rc)
 REXX
 Shadow Command Line Interface
 SpiritShadow Command Line Interface (2009)
 Tandem Advanced Command Language (TACL)

 कम्पाइल की जाने वाले भाषाएँ (Compiled languages) 
 Ada (multi-purpose language)
 ALGOL (extremely influential language design. The second high level language compiler.)
 SMALL Machine Algol Like Language
 Ateji PX, an extension of the Java language for parallelism
 BASIC (some dialects, including the first version of Dartmouth BASIC)
 C (one of the most widely-used procedural programming languages)
 C++
 CLIPPER 5.3 (Programming Language for dos base software)
 C# (compiled into Intermediate Language which is used to generate a native image at runtime)
 CLEO (Clear Language for Expressing Orders) used the compiler for the British Leo computers
 CLush (Lush)
 COBOL
 Cobra
 Common Lisp
 Corn
 Curl
 D (Attempts a "C++ done right" philosophy)
 DASL compiles into Java, JavaScript, JSP, Flex, etc., which are further compiled into a .war file
 Delphi (Borland's Object Pascal development system)
 DIBOL (Digital Interactive Business Oriented Language)
 Dylan
 dylan.NET
 eC (Ecere C)
 Eiffel (object-oriented language developed by Bertrand Meyer)
 Sather
 Ubercode
 Factor
 Forth (professional systems, like VFX and SwiftForth)
 Fortran (the first high level, compiled, language, from IBM, John Backus, et al.)
 Go
 Haskell
 Harbour
 Java (usually compiled into JVM bytecode although true native-code compiled versions exist)
 JOVIAL
 LabVIEW
 Nemerle (compiled into Intermediate Language bytecode)
 Objective-C
 Pascal (most implementations)
 Plus
 ppC++
 RPG (Report Program Generator)
 Scheme (some implementations, e.g. Gambit)
 Smalltalk generally compiled to platform independent bytecode that runs on a Virtual Machine.
 ML
 Standard ML
 Alice
 OCaml
 Turing
 Urq
 Visual Basic (earlier versions compiled directly to a native runtime. Recent .NET versions are compiled into Intermediate Language which is used to generate a native image at runtime)
 Visual FoxPro
 Visual Prolog
 WinDev
 X++
 XL
 Z++

 सहगामी भाषाएँ (Concurrent languages) 
इन भाषाओं में ऐसे प्रावधान हैं जो एक साथ कई कार्य ककराने वाले प्रोग्राम लिखने मेंसहायक होती हैं।
 Ada (multi-purpose language)
 Afnix – concurrent access to data is protected automatically (previously called Aleph, but unrelated to Alef)
 Alef – concurrent language with threads and message passing, used for systems programming in early versions of Plan 9 from Bell Labs
 Ateji PX an extension of the Java language for parallelism
 ChucK – domain specific programming language for audio, precise control over concurrency and timing
 Cilk – a concurrent C
 Cω – C Omega, a research language extending C#, uses asynchronous communication
 Clojure – a dialect of Lisp for the Java Virtual Machine
 ConcurrentLua – a Lua extension
 Concurrent Pascal (by Brinch-Hansen)
 Corn
 Curry
 E – uses promises, ensures deadlocks cannot occur
 Eiffel (through the SCOOP mechanism, Simple Concurrent Object-Oriented Computation)
 Erlang – uses asynchronous message passing with nothing shared
 Go
 Java
 Join Java – concurrent language based on Java
 X10
 Join-calculus
 Joule – dataflow language, communicates by message passing
 Limbo – relative of Alef, used for systems programming in Inferno (operating system)
 MultiLisp – Scheme variant extended to support parallelism
 occam – influenced heavily by Communicating Sequential Processes (CSP).
 occam-π – a modern variant of occam, which incorporates ideas from Milner's π-calculus
 Oz – multiparadigm language, supports shared-state and message-passing concurrency, and futures
 Mozart Programming System – multiplatform Oz
 Pict – essentially an executable implementation of Milner's π-calculus
 SALSA – actor language with token-passing, join, and first-class continuations for distributed computing over the Internet
 Scala – implements Erlang-style actors on the JVM
 SR – research language

 आंकड़ा-प्रवाह भाषाएँ (Dataflow languages) 

 Hartmann pipelines
 G (used in LabVIEW)
 Lucid
 Max
 Prograph
 Pure Data
 VEE
 VisSim
 WebMethods Flow
 Monk
 Oz
 VHDL

 आंकड़ामुखी भाषाएँ (Data-oriented languages) 
 Clarion
 Clipper
 dBase a relational database access language
 MUMPS (an ANSI standard general purpose language with specializations for database work.)
 SPARQL
 SQL
 Tutorial D, see also The Third Manifesto
 Visual FoxPro native rdbms engine, object oriented, functional, RAD
 WebQL

 डेटा-स्ट्रक्चर युक्त भाषाएँ (Data-structured languages) 
 Array-based
 List-based
 Stack-based

Assembly languages which statically link data inline with instructions can also be considered data-structured, in the most primitive way.

 वर्णनात्मक भाषाएँ (Declarative languages) 
ये भाषाएँ किसी समस्या का वर्णन करने के लिये उपयुक्त हैं न कि किसी समाधान या हल के लिये।
 Analytica
 Ant (partially Declarative languages, partially imperative programming)
 DASL (partially Declarative languages, partially imperative programming)
 Lustre
 MetaPost
 Modelica
 Prolog
 SQL
 xBase
 XSL Transformations
 Poses++ (language of the simulation system with the same name)

 इसोटेरिक भाषाएँ (Esoteric languages) 
ये भाषाएँ दूसरी प्रोग्रामन भाषाओं की सीमा की जाँच के लिये डिजाइन की गयी होती हैं।
 Befunge
 Brainfuck
 Chef
 FALSE
 INTERCAL
 LOLCODE
 Malbolge
 merd
 Piet
 Qwertycode
 Shakespeare
 SNUSP
 Var'aq (Klingon programming language)
 Whitespace

 एक्टेंशन भाषाएँ (Extension languages) 

ये भाषाएँ किसी दूसरे प्रोग्राम में 'इम्बेड' किये जाने योग्य प्रोग्राम लिखने के लिये बनी हैं।
 Ateji PX an extension of the Java language for parallelism
 AutoLISP (specific to AutoCAD)
 CAL
 C/AL(C/SIDE)
 DeScribe Macro Language (DML - specific to the DeScribe Word Processor)
 Guile
 Lua
 OptimJ an extension of the Java programming language with language support for writing optimization models and powerful abstractions for bulk data processing.
 Python (Maya and other 3-D animation packages)
 REXX
 Ruby (Google SketchUp)
 S-Lang
 SQL
 Tcl
 Vimscript
 VBA
 Windows PowerShell

 चौथी पीढ़ी की भाषाएँ (Fourth-generation languages) 
 ABAP
 ADMINS
 BuildProfessional
 CorVision
 CSC's GraphTalk
 dylan.NET
 Easytrieve report generator (now CA-Easytrieve Plus)
 FOCUS
 GEMBASE
 IBM Informix-4GL / Aubit-4GL
 LINC 4GL
 MAPPER (Unisys/Sperry) now part of BIS
 MARK-IV (Sterling/Informatics) now VISION:BUILDER of CA
 Oracle Express 4GL
 Progress 4GL
 Querix 4GL
 Revolution (not based on a database; still, the goal is to work at a higher level of abstraction than 3GLs)
 SAS
 Sculptor
 Today
 Ubercode (VHLL, or Very High Level Language)
 Uniface
 Visual DataFlex
 Visual FoxPro
 xBase
 XMLmosaic

 फंशनल भाषाएँ (Functional languages) 
ये भाषाएँ सभी प्रोग्रामों एवं सबरोटीनों को फंक्शन के रूप में परिभाषित करती हैं। 
 APL
 Charity (purely functional)
 Clean (purely functional)
 Curl
 Curry
 Erlang
 F#
 FPr
 Haskell (purely functional)
 CAL
 Hop
 J
 Joy
 Kite
 Lisp
 Clojure
 Common Lisp
 Dylan
 Little b
 Logo
 Scheme
 Tea
 Lush
 Mathematica
 Miranda
 ML
 Standard ML
 Alice
 Ocaml
 Mythryl
 Nemerle
 Opal
 OPS5
 Poplog
 R
 Q (equational programming language)
 Q (programming language from Kx Systems)
 REFAL
 Russell
 Scala
 Spreadsheets

 Interactive mode languages 

Interactive mode languages act as a kind of shell: expressions or statements can be entered one at a time, and the result of their evaluation is seen immediately.

 BASIC (some dialects)
 Clojure
 Common Lisp
 Erlang
 F#
 Forth
 FPr
 Fril
 Haskell (with the GHCi or Hugs interpreter)
 IDL
 Lua
 MUMPS (an ANSI standard general purpose language)
 Maple
 Mathematica
 MATLAB
 ML
 Mythryl
 Perl (with the perl shell, psh)
 PostScript
 Python
 R
 Scala
 REXX
 Ruby (with IRB)
 Scheme
 Smalltalk (anywhere in a Smalltalk environment)
 S-Lang (with the S-Lang shell, slsh)
 Tcl (with the Tcl shell, tclsh)
 Windows PowerShell (Microsoft .NET-based CLI)

 Interpreted languages 

Interpreted languages are programming languages which programs may be executed from source code form, by an interpreter. Theoretically, any language can be compiled or interpreted, so the term *interpreted language* generally refers to languages that are commonly interpreted rather than compiled.

 Ant
 APL
 AutoHotkey scripting language
 AutoIt scripting language
 BASIC (some dialects)
 DATABUS (later versions added optional compiling)
 Eiffel (via "Melting Ice Technology" in EiffelStudio)
 Forth (interactive shell only; otherwise compiled to native or threaded code)
 FPr (Virtual machine: Text is compiled to linked lists; linked lists are interpreted)
 Frink
 Game Maker Language
 Groovy
 Haskell (GHCi, Hugs, NHC, YHC etc.)
 J
 Lisp (early versions, pre-1962, and some experimental ones; production Lisp systems are compilers, but many of them still provide an interpreter if needed)
 Tea
 LPC
 Lua
 Lush
 MUMPS (an ANSI standard general purpose language)
 Maple
 Mathematica
 Pascal (early implementations)
 PCASTL
 Perl
 Pikt
 PostScript
 Python
 REXX
 R
 Ruby
 S-Lang
 Spin
 Tcl
 TorqueScript
 thinBasic scripting language
 VBScript
 Windows PowerShell (Microsoft .NET-based CLI)
 XMLmosaic
 Some scripting languages (below)

 Iterative languages 

Iterative languages are built around or offering generators.

 Aldor
 Alphard
 C#
 CLU
 Cobra
 Eiffel, through "agents"
 Icon
 IPL-v
 Lua
 Lush
 Python
 Sather
 XL ("iterator" construct)

 List-based languages – LISPs 

List-based languages are a type of data-structured language that are based upon the list data structure.

 FPr
 Joy
 Lisp
 Common Lisp
 Arc
 Dylan
 Scheme
 Logo
 Lush
 R
 Tcl
 Tea
 TRAC

 Little languages 

Little languages serve a specialized problem domain.

 apply is a domain-specific language for image processing on parallel and conventional architectures
 awk can serve as a prototyping language for C, because the syntax is similar
 Comet is used to solve complex combinatorial optimization problems in areas such as resource allocation and scheduling.
 SQL has only a few keywords, and not all the constructs needed for a full programming language. Many database management systems extend SQL with additional constructs as a stored procedure language.

 Logic-based languages 

Logic-based languages specify a set of attributes that a solution must have, rather than a set of steps to obtain a solution. Examples:

 ALF
 Alma-0
 CLACL (CLAC-Language)
 Curry
 Fril
 Janus
 Leda
 Oz
 Mozart Programming System a multiplatform Oz
 Poplog
 Prolog (formulates data and the program evaluation mechanism as a special form of mathematical logic called Horn logic and a general proving mechanism called logical resolution)
 Mercury (based on Prolog)
 Strawberry Prolog (standard Prolog with some extensions)
 Visual Prolog (object-oriented Prolog extension)
 ROOP

 Machine languages 

Machine languages are directly executable by a computer's CPU. They are typically formulated as bit patterns, usually represented in octal or hexadecimal. Each group of npatterns (often 1 or more bytes) causes the circuits in the CPU to execute one of the fundamental operations of the hardware. The activation of specific electrical inputs (e.g., CPU package pins for microprocessors), and logical settings for CPU state values, control the processor's computation. Individual machine languages are processor specific and are not portable. They are (essentially) always defined by the CPU developer, not by 3rd parties. The symbolic version, the processor's assembly language, is also defined by the developer, in most cases. Since processors come in families which are based on a shared architecture, the same basic assembly language style can often be used for more than one CPU. Each of the following CPUs served as the basis for a family of processors:

 ARM
 Intel 80x86
 IBM System/360
 Intel 8008/8080/8085
 MIPS R2000/R3000
 MOS Tech 6502 and 6510 (Commodore 64 CPU)
 Motorola 6800
 Motorola 68000 family
 National 32032
 Power Architecture - (POWER and PowerPC)
 StrongARM
 Sun SPARC, UltraSPARC

 Macro languages 

Macro languages embed small pieces of executable code inside a piece of free-form text.
 cpp (the C preprocessor)
 m4 (originally from AT&T, bundled with UNIX)
 PHP
 SMX, dedicated to web pages

Scripting languages such as Tcl and ECMAScript (ActionScript, DMDScript, ECMAScript for XML, JavaScript, JScript) have been embedded into applications so that they behave like macro languages.

 Metaprogramming languages 
Metaprogramming is writing of programs that write or manipulate other programs (or themselves) as their data or that do part of the work that is otherwise done at run time during compile time. In many cases, this allows programmers to get more done in the same amount of time as they would take to write all the code manually.
 C++
 Curl
 D
 Forth
 Haskell
 Lisp
 Lua
 Maude system
 Mathematica
 MetaL
 MetaOCaml
 Nemerle
 Perl
 Python
 Ruby
 Smalltalk
 XL (concept programming)

 Multiparadigm languages 

Multiparadigm languages support more than one programming paradigm. They allow a program to use more than one programming style. The goal is to allow programmers to use the best tool for a job, admitting that no one paradigm solves all problems in the easiest or most efficient way.

 Ada (concurrent, distributed, generic (template metaprogramming), imperative, object-oriented (class-based))
 ALF (functional, logic)
 Alma-0 (constraint, imperative, logic)
 APL (functional, imperative)
 BETA (functional, imperative, object-oriented (class-based))
 C++ (generic, imperative, object-oriented (class-based))
 C# (generic, imperative, object-oriented (class-based), functional, declarative)
 ChucK (imperative, object-oriented, time-based, concurrent, on-the-fly)
 Cobra (generic, imperative, object-oriented (class-based), functional, contractual)
 Common Lisp (functional, imperative, object-oriented (class-based), aspect-oriented (user may add further paradigms, e.g., logic))
 Corn (concurrent, generic, imperative, object-oriented (class-based))
 Curl (functional, imperative, object-oriented (class-based), metaprogramming)
 Curry (concurrent, functional, logic)
 D (generic, imperative, functional, object-oriented (class-based), metaprogramming)
 Delphi (generic, imperative, object-oriented (class-based), metaprogramming)
 Dylan (functional, object-oriented (class-based))
 ECMAScript (functional, imperative, object-oriented (prototype-based))
 ActionScript
 DMDScript
 ECMAScript for XML
 JavaScript
 JScript
 Eiffel (imperative, object-oriented (class-based), generic)
 F# (functional, generic, object-oriented (class-based), language-oriented)
 Fantom (functional, object-oriented (class-based))
 FPr (function-level, object-oriented (class-based))
 Harbour
 Hop
 J (functional, imperative, object-oriented (class-based))
 LabVIEW (dataflow, visual)
 Lasso (macro, object-oriented (prototype-based), procedural, scripting)
 Lava (object-oriented (class-based), visual)
 Leda (functional, imperative, logic, object-oriented (class-based))
 Lua (functional, imperative, object-oriented (prototype-based))
 Metaobject protocols (object-oriented (class-based, prototype-based))
 Mythryl (functional, imperative)
 Nemerle (functional, object-oriented (class-based), imperative, metaprogramming)
 Objective Caml (functional, imperative, object-oriented (class-based))
 Oz (functional (evaluation: eager, lazy), logic, constraint, imperative, object-oriented (class-based), concurrent, distributed)
 Mozart Programming System (multiplatform Oz)
 Object Pascal (imperative, object-oriented (class-based))
 Perl (imperative, functional (can't be purely functional), object-oriented, class-oriented, aspect-oriented (through modules))
 PHP (imperative, object-oriented)
 Pliant (functional, imperative, object-oriented (class-based))
 Poplog (functional, imperative, logic)
 ppC++ (imperative, object-oriented (class-based))
 Prograph (dataflow, object-oriented (class-based), visual)
 Python (functional, object-oriented (class-based), imperative)
 R
 REBOL (functional, imperative, object-oriented (prototype-based), metaprogramming (dialected))
 ROOP (imperative, logic, object-oriented (class-based), rule-based)
 Ruby (functional, object-oriented (class-based))
 Scala (functional, object-oriented)
 Seed7 (imperative, object-oriented, generic)
 SISAL (concurrent, dataflow, functional)
 Spreadsheets (functional, visual)
 Tcl (functional, imperative, object-oriented (class-based))
 Tea (functional, imperative, object-oriented (class-based))
 Windows PowerShell (functional, imperative, pipeline, object-oriented (class-based))
 XL (concept programming approach)

 Numerical analysis 

 Algae
 AMPL
 GAMS
 MATLAB
 Seneca an Oberon variant

 Non-English-based languages 

 ARLOGO - Arabic
 Chinese BASIC - Chinese
 Fjölnir - Icelandic
 HPL - Hebrew
 Lexico - Spanish
 Rapira - Russian
 Glagol - Russian
 Portugol - Portuguese

 Object-oriented class-based languages 

Class-based Object-oriented programming languages support objects defined by their class. Class definitions include member data. Message passing is a key concept (if not the key concept) in Object-oriented languages. 

Polymorphic functions parameterized by the class of some of their arguments are typically called methods. In languages with single dispatch, classes typically also include method definitions. In languages with multiple dispatch, methods are defined by generic functions. There are exceptions where single dispatch methods are generic functions (e.g. Bigloo's object system).

 Multiple dispatch 

 Common Lisp
 Dylan
 Goo
 Cecil

 Single dispatch 

 Actor
 Ada 95 and Ada 2005 (multi-purpose language)
 BETA
 C++
 C#
 Chrome
 ChucK
 Cobra
 ColdFusion
 Corn
 Curl
 D
 DASL
 Delphi
 dylan.NET
 E
 eC (Ecere C)
 Eiffel
 Sather
 Ubercode
 F-Script
 Fortran 2003
 Fortress
 FPr
 Gambas
 Game Maker Language
 Harbour
 J
 Java
 Groovy
 Join Java
 Tea
 X10
 JavaScript
 Kite
 LabVIEW
 Lava
 Lua
 Modula-2 (data abstraction, information hiding, strong typing, full modularity)
 Modula-3 (added more object oriented features to Modula-2)
 Moto
 Nemerle
 IBM NetRexx
 Oberon-2 (full object orientation equivalence in an original, strongly typed, Wirthian manner)
 Object Pascal
 Object REXX
 Objective-C (a superset of C adding a Smalltalk derived object model and message passing syntax)
 Objective Caml
 Oz
 Mozart Programming System
 Perl 5
 PHP
 Pliant
 ppC++
 Prograph
 Python (object oriented interpretive language)
 Revolution (programmer does not get to pick the objects)
 Ruby
 Scala
 Seccia (assisted object-oriented programming)
 Simula (the first object oriented language, developed by Ole-Johan Dahl and Kristen Nygaard)
 Smalltalk (pure object-orientation, developed at Xerox PARC)
 Bistro
 F-Script
 Little Smalltalk
 Squeak
 Scratch
 IBM VisualAge
 VisualWorks
 SPIN
 SuperCollider
 VBScript (Microsoft Office 'macro scripting' language)
 Visual DataFlex
 Visual FoxPro
 Visual Prolog
 X++
 XOTcl

 Object-oriented prototype-based languages 

Prototype-based languages are object-oriented languages where the distinction between classes and instances have been removed:

 ABCL/1
 ABCL/R
 ABCL/R2
 ABCL/c plus
 Agora
 Cecil
 ECMAScript
 ActionScript
 DMDScript
 ECMAScript for XML
 JavaScript (first named Mocha, then LiveScript)
 JScript
 Etoys in Squeak
 Glyphic Script
 Io
 Lisaac
 Lua
 MOO
 NewtonScript
 Obliq
 R
 REBOL
 Self (the first prototype-based language, derived from Smalltalk)
 Slate
 TADS

 Off-side rule languages 

Off-side rule languages are those where blocks are formed, indicated, by their indentation.

 ISWIM, the abstract language that introduced the rule
 ABC, Python's parent
 Python
 Cobra
 Boo
 HyperTalk
 Ivy
 Miranda, Haskell's parent
 Orwell
 Haskell
 Curry
 Occam
 Pliant
 SPIN
 XL

 Procedural languages 

Procedural programming languages are based on the concept of the unit and scope (the data viewing range of an executable code statement). A procedural program is composed of one or more units or modules, either user coded or provided in a code library; each module is composed of one or more procedures, also called a function, routine, subroutine, or method, depending on the language. Examples of procedural languages include:

 Ada (multi-purpose language)
 ALGOL (extremely influential language design. The second high level language compiler.)
 SMALL Machine Algol Like Language
 Alma-0
 BASIC (BASICs are innocent of most modularity in (especially) versions prior to about 1990)
 BLISS
 C
 C++ (C with objects + much else)
 C# (similar to Java/C++)
 ChucK (C/Java-like syntax, with new syntax elements for time and parallelism)
 COBOL
 Cobra
 ColdFusion
 Component Pascal (an Oberon-2 variant)
 Curl
 D
 DASL (partially Declarative languages, partially imperative programming)
 dylan.NET
 Delphi
 eC (Ecere C)
 ECMAScript
 ActionScript
 DMDScript
 ECMAScript for XML
 JavaScript (first named Mocha, then LiveScript)
 JScript
 Eiffel
 Fortran (better modularity in later Standards)
 F
 FPC Pascal (Pascal dialect)
 Harbour
 HyperTalk
 Java
 Groovy
 Join Java
 Tea
 JOVIAL
 Lasso
 Modula-2 (fundamentally based on modules)
 Oberon and Oberon-2 (improved, smaller, faster, safer follow-ons for Modula-2)
 Component Pascal
 Lagoona
 Seneca
 MATLAB
 MUMPS (more modular in its first release than a language of the time should have been; the standard has become still more modular since then)
 Nemerle
 Occam
 Pascal (successor to Algol60 and predecessor of Modula-2)
 Object Pascal
 PCASTL
 Perl
 PL/C
 PL/I (large general purpose language, originally for IBM mainframes)
 Plus
 Python
 R
 Rapira
 RPG (only available in IBM's System i midrange computers)
 S-Lang
 VBScript
 Visual Basic
 Visual FoxPro
 X++
 XL
 XMLmosaic

 Reflective languages 

Reflective languages let programs examine and possibly modify their high level structure at runtime. This is most common in high-level virtual machine programming languages like Smalltalk, and less common in lower-level programming languages like C. Languages and platforms supporting reflection:

 Aspect-oriented
 Befunge
 C#
 ChucK
 Cobra
 Component Pascal BlackBox Component Builder
 Curl
 Delphi
 ECMAScript
 ActionScript
 DMDScript
 ECMAScript for XML
 JavaScript
 JScript
 Eiffel
 Forth
 Harbour
 Java
 Java Virtual Machine
 Groovy
 Join Java
 X10
 Lisp
 Clojure
 Common Lisp
 Dylan
 Logo
 Scheme
 Lua
 Maude system
 .NET Framework Common Language Runtime
 Oberon-2 ETH Oberon System
 Objective-C
 PCASTL
 Perl
 PHP
 Pico
 Pliant
 Poplog
 POP-11
 Prolog
 Python
 REBOL
 Ruby
 Smalltalk (pure object-orientation, originally from Xerox PARC)
 Bistro
 F-Script
 Little Smalltalk
 Self
 Squeak
 IBM VisualAge
 VisualWorks
 Snobol
 Tcl
 XOTcl
 X++
 XL

 Rule-based languages 

Rule-based languages instantiate rules when activated by conditions in a set of data. Of all possible activations, some set will be selected and the statements belonging to those rules will be executed. Examples of rule-based languages include:

 CLIPS
 Constraint Handling Rules
 Jess
 OPS5
 Prolog
 Poses++ (language of the simulation system with the same name)

 Scripting languages 

"Scripting language" has two apparently different, but in fact similar meanings. In a traditional sense, scripting languages are designed to automate frequently used tasks that usually involve calling or passing commands to external programs. Many complex application programs allow users to implement custom functions by providing them with built-in languages. Those which are of interpretive type, are often called scripting languages.

More recently many of these applications have chosen to "build in" traditional scripting languages, such as Perl or Visual Basic, but there are quite a few "native" scripting languages still in use. Many scripting languages are compiled to bytecode and then this (usually) platform independent bytecode is run through a virtual machine (compare to Java).

 AppleScript
 AWK
 BeanShell
 Ch (Embeddable C/C++ interpreter)
 CLIST
 ColdFusion
 ECMAScript
 ActionScript
 DMDScript
 ECMAScript for XML
 JavaScript (first named Mocha, then LiveScript)
 JScript
 CMS EXEC
 EXEC 2
 F-Script
 Falcon
 Frink
 Game Maker Language (GML)
 ICI
 Io
 JASS
 Groovy
 Join Java
 Tea
 Lua
 MAXScript
 MEL
 Mondrian
 Mythryl
 Perl
 PHP (intended for Web servers)
 Pikt
 Python
 R
 REBOL
 REXX
 Revolution
 Ruby
 Smalltalk
 S-Lang
 sed
 Tcl
 TorqueScript
 VBScript
 Windows PowerShell (Microsoft .NET-based CLI)
 Winbatch
 Many shell command languages such as the UNIX shell or DCL on VMS have powerful scripting capabilities.

 Stack-based languages 

Stack-based languages are a type of data-structured language that are based upon the stack data structure.

 Cat
 colorForth
 Factor
 Forth
 Joy (all functions work on parameter stacks instead of named parameters)
 Piet
 Poplog via its implementation language POP-11
 PostScript
 RPL
 Urq

 Synchronous languages 

Synchronous programming languages are optimized for programming reactive systems, systems that are often interrupted and must respond quickly. Many such systems are also called realtime systems, and are found often in embedded uses. Examples:

 Argus
 Averest
 Esterel
 LEA
 Lustre
 Signal
 SyncCharts

 Syntax handling languages 
These languages assist with generating lexical analzyers and parsers for Context-free grammars.
 ANTLR
 Coco/R (EBNF with semantics)
 GNU bison (FSF's version of Yacc)
 GNU Flex (FSF's version of Lex)
 lex (Lexical Analysis, from Bell Labs)
 M4
 yacc (yet another compiler compiler, from Bell Labs)
 JavaCC
 Rats!

 Visual languages 

Visual programming languages let users specify programs in a two-(or more)-dimensional way, instead of as one-dimensional text strings, via graphic layouts of various types.

 CODE
 Eiffel (program design from BON or UML diagrams, with back-and-forth facilities (round-trip engineering) through EiffelStudio)
 Fabrik
 FlowStone DSP
 Hyperpascal
 LabVIEW
 Lava
 Limnor
 Mindscript — software visualization and development environment, open source
 Max
 NXT-G
 Pict programming language
 Prograph
 Pure Data
 Quartz Composer
 Scratch (written in and based on Squeak, a version of Smalltalk)
 Simulink
 Spreadsheets
 Subtext
 Tinkertoy
 VEE
 VisSim
 vvvv
 EICASLAB
Some dataflow programming languages are also visual languages.

 Wirth languages 

Computer scientist Niklaus Wirth designed and implemented several influential languages.

 ALGOL W
 Modula
 Modula-2 (and Modula 3, etc. variants)
 Obliq Modula 3 variant
 Oberon (Oberon, Oberon-07, and Oberon-2)
 Component Pascal
 Lagoona
 Oberon-2
 Pascal
 Object Pascal (original name for Borland Delphi language)

 XML-आधारित भाषाएँ 

These are languages based on or that operate on XML. Although the big-boy equivalents of Oracle/PostgreSQL/MSSQL don't yet exist for XML, there are languages to navigate through it and its more tree-oriented structure.

 Ant
 Cω
 ECMAScript ECMAScript for XML
 Jelly
 LZX
 MXML
 XPath
 XQuery
 XSLT
 XMLmosaic

 इन्हें भी देखें 
 प्रोग्रामन भाषाओं की सूची (वर्णक्रमानुसार)

श्रेणी:प्रोग्रामन भाषा