{"id":13813346,"url":"https://github.com/vindarel/languages-that-compile-to-python","last_synced_at":"2025-07-29T00:34:22.560Z","repository":{"id":48166887,"uuid":"61726783","full_name":"vindarel/languages-that-compile-to-python","owner":"vindarel","description":"List of languages that compile to python","archived":false,"fork":false,"pushed_at":"2024-02-06T11:34:34.000Z","size":49,"stargazers_count":267,"open_issues_count":3,"forks_count":14,"subscribers_count":15,"default_branch":"master","last_synced_at":"2025-05-20T14:06:56.348Z","etag":null,"topics":[],"latest_commit_sha":null,"homepage":"","language":null,"has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":null,"status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/vindarel.png","metadata":{"files":{"readme":"README.md","changelog":null,"contributing":null,"funding":null,"license":null,"code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null,"zenodo":null},"funding":{"github":["vindarel"],"ko_fi":"vindarel"}},"created_at":"2016-06-22T14:43:54.000Z","updated_at":"2025-05-17T09:24:08.000Z","dependencies_parsed_at":"2024-02-06T13:32:02.854Z","dependency_job_id":null,"html_url":"https://github.com/vindarel/languages-that-compile-to-python","commit_stats":null,"previous_names":[],"tags_count":0,"template":false,"template_full_name":null,"purl":"pkg:github/vindarel/languages-that-compile-to-python","repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/vindarel%2Flanguages-that-compile-to-python","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/vindarel%2Flanguages-that-compile-to-python/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/vindarel%2Flanguages-that-compile-to-python/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/vindarel%2Flanguages-that-compile-to-python/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/vindarel","download_url":"https://codeload.github.com/vindarel/languages-that-compile-to-python/tar.gz/refs/heads/master","sbom_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/vindarel%2Flanguages-that-compile-to-python/sbom","host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":267610438,"owners_count":24115435,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2022-07-04T15:15:14.044Z","status":"online","status_checked_at":"2025-07-28T02:00:09.689Z","response_time":68,"last_error":null,"robots_txt_status":"success","robots_txt_updated_at":"2025-07-24T06:49:26.215Z","robots_txt_url":"https://github.com/robots.txt","online":true,"can_crawl_api":true,"host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":[],"created_at":"2024-08-04T04:01:13.986Z","updated_at":"2025-07-29T00:34:22.534Z","avatar_url":"https://github.com/vindarel.png","language":null,"readme":"We have variants of Python that can use Python libs: welcome to\n**Dogelang**, **Mochi**, **Hy**, **Coconut** and **Hask**.\n\nWe can also have languages that target the Python platform without\nbeing necessarily compatible with Python, and domain-specific\nlanguages.\n\nFor more ressources related to functional programming in Python, see\nthe [Awesome Functional Python](https://github.com/sfermigier/awesome-functional-python)\nlist.\n\n\u003c!-- generetae the toc with npm install markdown-toc and running markdown-toc -i README.md --\u003e\n\n\u003c!-- toc --\u003e\n\n\u003c!-- markdown-toc start - Don't edit this section. Run M-x markdown-toc-refresh-toc --\u003e\n**Table of Contents**\n\n- [Variants of Python. They can use Python libs.](#variants-of-python-they-can-use-python-libs)\n    - [Dg - it's a Python ! No, it's a Haskell !](#dg---its-a-python--no-its-a-haskell-)\n    - [Hissp - It's Python with a Lissp!](#hissp---its-python-with-a-lissp)\n    - [Hy - A dialect of Lisp that's embedded in Python](#hy---a-dialect-of-lisp-thats-embedded-in-python)\n    - [Basilisp -  a Clojure-compatible(-ish) Lisp dialect targeting Python 3.8+](#basilisp----a-clojure-compatible-ish-lisp-dialect-targeting-python-38)\n    - [Mochi - Dynamically typed programming language for functional programming and actor-style programming](#mochi---dynamically-typed-programming-language-for-functional-programming-and-actor-style-programming)\n    - [Coconut - Simple, elegant, Pythonic functional programming](#coconut---simple-elegant-pythonic-functional-programming)\n    - [Hask -  Haskell language features and standard libraries in pure Python.](#hask----haskell-language-features-and-standard-libraries-in-pure-python)\n    - [Rabbit - a functional language on top of Python (discontinued in favor of Coconut)](#rabbit---a-functional-language-on-top-of-python-discontinued-in-favor-of-coconut)\n    - [MakrellPy - a functional language with metaprogramming support and simplistic syntax](#makrellpy---a-functional-language-with-metaprogramming-support-and-simplistic-syntax)\n- [Implemented in another language but target the Python platform. They can use Python libs.](#implemented-in-another-language-but-target-the-python-platform-they-can-use-python-libs)\n    - [Erg - General statically typed multiparadigm rusty programming language](#erg---general-statically-typed-multiparadigm-rusty-programming-language)\n- [Other languages that target the Python platform](#other-languages-that-target-the-python-platform)\n    - [Haxe, the cross-platform toolkit](#haxe-the-cross-platform-toolkit)\n- [Domain-specific languages](#domain-specific-languages)\n    - [ProbLog. Probabilistic Logic Programming.](#problog-probabilistic-logic-programming)\n    - [PyDatalog. Logic programming to use inside your Python program.](#pydatalog-logic-programming-to-use-inside-your-python-program)\n    - [RBQL: SQL dialect with Python expressions](#rbql-sql-dialect-with-python-expressions)\n- [Other languages built in RPython](#other-languages-built-in-rpython)\n    - [Monte - secure distributed computation](#monte---secure-distributed-computation)\n    - [Pixie, a lightweight and native lisp](#pixie-a-lightweight-and-native-lisp)\n    - [RSqueak, a Squeak/Smalltalk VM written in RPython](#rsqueak-a-squeaksmalltalk-vm-written-in-rpython)\n\n\u003c!-- markdown-toc end --\u003e\n\n\u003c!-- tocstop --\u003e\n\n# Variants of Python. They can use Python libs.\n\nThe following languages can make use of the Python libraries.\n\n## Dg - it's a Python ! No, it's a Haskell !\n\n![NOT'REALLY®](https://pyos.github.io/dg/images/seriousdawg.jpg)\n\nDogelang  |  \n--- | ---\nsources |[\u003chttps://github.com/pyos/dg\u003e](https://github.com/pyos/dg)\ndoc | [\u003chttps://pyos.github.io/dg/\u003e](https://pyos.github.io/dg/)\nv1 ? | yes, april 2015\ncreated | june, 2012\n\n-   compiles to CPython 3.4. Dg is an alternative syntax to Python 3.\n-   compatible with all the libraries\n-   runs on PyPy\n\n### Language features\n\n-   function calls without parenthesis:\n\n```livescript\nprint \"wow\" \"two lines\" sep: \"\\n\"\n```\n\n-   reverse pipe operator:\n\n```livescript\nprint $ \"\u003e {}: {}\".format \"Karkat\" \"Reference something other than Doge\"\n```\n\n-   pipe and reverse pipe (on the same line, unlike Mochi)\n\n```livescript\nprint \u003c| 'What' + 'ever.' : 'This is the same thing ' + 'in a different direction.' |\u003e print\n```\n\n-   function notation (arrow `-\u003e` notation)\n\n```livescript\nfunction = arg1 arg2 -\u003e : print (arg1.replace \"Do \" \"Did \") arg2 sep: \", \" end: \".\\n\"\nfunction \"Do something\" \"dammit\"\n```\n\n-   infix notation (with backticks)\n-   function composition (with `\u003c-`)\n-   first class operators\n\n```livescript\nf = (+)\nf 1 2 == 3\n```\n\n-   partial application (and `bind` is `functools.partial`)\n\n```livescript\nf = (2 *)\nf 10 == 20\n```\n\n-   new functional builtins: `foldl` and `foldl1`, `scanl`, `flip`,\n    `takewhile` and `dropwhile` (from `itertools`), `take` and `drop`,\n    `iterate`, `head` and `fst`, `tail`, `snd`, `last` and `init`.\n-   decorators don't need special syntax, they're just called with a\n    function\n\n        wtf = the~decorator~ $ -\u003e\n\n### Install\n\n        pip3 install git+\u003chttps://github.com/pyos/dg\u003e\n\n### Editors\n\nEditor |  \n  --------- | --------------------------------------------------------------------------------\n  Gedit |     [\u003chttps://github.com/pyos/dg-gedit/\u003e](https://github.com/pyos/dg-gedit/)\n  Sublime |   [\u003chttps://github.com/pyos/dg-textmate/\u003e](https://github.com/pyos/dg-textmate/)\n\nPygments support.\n\n### Example projects\n\n\nProject |  \n--- | ---\ndogeweb , a functional web framework atop asyncio |   [\u003chttps://pyos.github.io/dogeweb/\u003e](https://pyos.github.io/dogeweb/)\n\n\n## Hissp - It's Python with a Lissp!\n\n![](https://raw.githubusercontent.com/gilch/hissp/master/docs/hissp.svg)\n\n\u003e Hissp is a modular Lisp implementation that compiles to a functional subset of Python—Syntactic macro metaprogramming with full access to the Python ecosystem!\n\nHissp |  \n-------------|------------------------------------------------------------------------\nsources |      [\u003chttps://github.com/gilch/hissp\u003e](https://github.com/gilch/hissp)\n  doc   |       [https://hissp.readthedocs.io/](https://hissp.readthedocs.io/)\n  v1 ?  |       no, v0.2 as of May 2021\n  created|       2019\n  discuss     | [gitter](https://gitter.im/hissp-lang/community)\n\nThe Hissp compiler is written in Python 3.8.\n\n### Language features\n\n\u003e The Hissp compiler should include what it needs to achieve its goals, but no more. Bloat is not allowed.\n\n\u003e Hissp compiles to an unpythonic functional subset of Python.\n\n\u003e Hissp's basic macros are meant to be just enough to bootstrap native unit tests and demonstrate the macro system. They may suffice for small embedded Hissp projects, but you will probably want a more comprehensive macro suite for general use.\n\n\u003e You do not need Hissp installed to run the final compiled Python output\n\n\n```lisp\n(defmacro attach (target : :* args)\n  \"Attaches the named variables as attributes of the target.\n\n  Positional arguments use the same name as the variable.\n  Names after the ``:`` are key-value pairs.\n  \"\n  (let (iargs (iter args)\n        $target `$#target)\n    (let (args (itertools..takewhile (lambda (a)\n                                       (operator..ne a ':))\n                                     iargs))\n      `(let (,$target ,target)\n         ,@(map (lambda (arg)\n                  `(setattr ,$target ',arg ,arg))\n                args)\n         ,@(map (lambda (kw)\n                  `(setattr ,$target ',kw ,(next iargs)))\n                iargs)\n         ,$target))))\n```\n\n\n## Hy - A dialect of Lisp that's embedded in Python\n\n![](http://docs.hylang.org/en/stable/_images/hy-logo-small.png)\n\nHy |  \n-------------|------------------------------------------------------------------------\nsources |      [\u003chttps://github.com/hylang/hy/\u003e](https://github.com/hylang/hy/)\n  doc   |       [\u003chttp://hylang.org/\u003e](http://hylang.org/)\n  v1 ?  |       no\n  created|       december, 2012\n  online REPL |   [\u003chttps://try-hy.appspot.com/\u003e](https://try-hy.appspot.com/)\n  discuss     | [google group](https://groups.google.com/forum/#!forum/hylang-discuss)\n  IRC         | `hy` on freenode\n\n-   Hy compiles to Python bytecode (AST)\n-   Hy can use python libraries, and we can import a Hy module into a\n    Python program.\n\n### Language features\n\n-   it's python: context managers, named and keyword arguments, list\n    comprehensions,...\n-   macros, reader macros\n-   threading macros (like Clojure), with `-\u003e` and `-\u003e\u003e` (similar to\n    pipes)\n\n```lisp\n(-\u003e (read) (eval) (print) (loop))\n```\n\n```lisp\n(import [sh [cat grep wc]])\n(-\u003e (cat \"/usr/share/dict/words\") (grep \"-E\" \"^hy\") (wc \"-l\"))  ; =\u003e 210\n```\n\n-   [anaphoric\n    functions](http://docs.hylang.org/en/latest/contrib/anaphoric.html)\n\n```lisp\n(require hy.contrib.anaphoric)\n(list (ap-map (* it 2) [1 2 3]))  ; =\u003e [2, 4, 6]\n```\n\n-   fraction literal (like Clojure)\n-   unicode support (I mean for symbols)\n-   pattern matching (in libraries, like\n    [Hyskell](https://github.com/kirbyfan64/hyskell))\n-   monads (in libraries, like [Hymn](https://github.com/pyx/hymn))\n\n### Install\n\n        pip install hy\n\n### Editors\n\nEditor |  \n  ------- | --------------------------------------------------------------------------\n  Emacs |   [\u003chttps://github.com/hylang/hy-mode\u003e](https://github.com/hylang/hy-mode)\n  All   |  lisp modes for any editor\n\n### Example projects\n\nProject |  \n--- | ---\n  Github trending |       [\u003chttps://github.com/trending/hy\u003e](https://github.com/trending/hy)\n  Live coding Blender |   [\u003chttps://github.com/chr15m/blender-hylang-live-code\u003e](https://github.com/chr15m/blender-hylang-live-code)\n\n### Good reads\n\nTitle |  \n--- | ---\nHow Hy backported \"yield from\" to Python 2 |   [\u003chttp://dustycloud.org/blog/how-hy-backported-yield-from-to-python2/\u003e](http://dustycloud.org/blog/how-hy-backported-yield-from-to-python2/)\n\n## Basilisp -  a Clojure-compatible(-ish) Lisp dialect targeting Python 3.8+\n\nBasilisp |  \n  ---------|----------------------------------------------------------------\n  sources  |[https://github.com/basilisp-lang/basilisp](https://github.com/basilisp-lang/basilisp)\n  doc | [https://basilisp.readthedocs.io/en/latest/](https://basilisp.readthedocs.io/en/latest/)\n  v1 ?  | no (as of 2024, Jan) but \"generally stable at this point\"\n  created |  initial development release in 2018\n\n### Language features\n\n- Immutable data structures, backed by Immutables and Pyrsistent\n- Strong emphasis on functional programming concepts\n- Access to the vast array of existing Python libraries\n- Seamless interoperability between Python code and Basilisp code\n- Sophisticated REPL for REPL-based development\n\nPlanned features:\n\n\u003e Basilisp is still young and so lacks many features that more mature languages and runtimes might include. There are many such planned features that will hopefully improve the ergonomics of the project for new developers.\n\n\u003e  fundamental differences and omissions in Basilisp that make it differ from Clojure:\n\n- Basilisp does not include Ref types or software transactional memory (STM) support.\n- Basilisp does not include Agent support (support is tracked in #413).\n- All Vars are reified at runtime and users may use the binding macro as in Clojure.\n- Support for Clojure libs is planned.\n- Type hints may be applied anywhere they are supported in Clojure (as the :tag metadata key), but the compiler does not currently use them for any purpose.\n\n```lisp\n(def\n  ^{:doc      \"Returns the second element in a Seq.\"\n    :arglists '([seq])}\n  second\n  (fn* second [seq] (first (rest seq))))\n```\n\n\n## Mochi - Dynamically typed programming language for functional programming and actor-style programming\n\nMochi |  \n  ---------|----------------------------------------------------------------\n  sources  |[\u003chttps://github.com/i2y/mochi\u003e](https://github.com/i2y/mochi)\n  doc | [many examples](https://github.com/i2y/mochi/tree/master/examples)\n  v1 ?  | no\n  created |  v0.1 on december, 2014\n\n-   translates to Python3's AST/bytecode\n\n### Language features\n\n-   Python-like syntax\n-   pipeline operator (multiline ok)\n\n```elixir\nrange(1, 31)\n|\u003e map(fizzbuzz)\n|\u003e pvector()\n|\u003e print()\n```\n\n-   tail-recursion optimization (self tail recursion only)\n-   no loop syntax\n-   re-assignments are not allowed in function definition\n-   persisent data structures (using Pyrsistent)\n-   Pattern matching / Data types, like algebraic data types\n-   Syntax sugar of anonymous function definition (`-\u003e` notation and\n    `$1` for the arguments)\n-   Actor, like the actor of Erlang (using Eventlet)\n-   Macro, like the traditional macro of Lisp\n-   Anaphoric macros\n-   Builtin functions includes functions exported by itertools module,\n    recipes, functools module and operator module\n\n### Install\n\n        pip3 install mochi\n\n### Editors\n\nEditor |  \n  ------|----------------------------------------------------------------------------------\n  Atom  | [\u003chttps://github.com/i2y/language-mochi\u003e](https://github.com/i2y/language-mochi)\n\n### Good reads\n\n* [Heny Müller's talk at EuroPython 2015](https://www.youtube.com/watch?v=bFqQd1eyY10)\n\n## Coconut - Simple, elegant, Pythonic functional programming\n\nCoconut |  \n---------|  ------------------------------------------------------------------------\n sources |   [\u003chttps://github.com/evhub/coconut\u003e](https://github.com/evhub/coconut)\n doc     | [\u003chttps://coconut.readthedocs.io\u003e](https://coconut.readthedocs.io)\n v1 ?    |  yes, on june, 2016\n created |   february, 2015 (v0.1)\n\n-   Coconut compiles to Python (not CPython bytecode, so it supports\n    other Python implementations: PyPy, Jython, etc)\n-   Coconut code runs on any major Python version, 2 or 3\n-   all valid Python 3 is valid Coconut: you can write standard Python3\n    in Coconut.\n\n-   **ipython** / jupyter\n    [support](http://coconut.readthedocs.io/en/master/DOCS.html#ipython-jupyter-support)\n    (installed by default)\n\n### Language features\n\n-   pipelines\n\n```livescript\n(1, 2) |*\u003e (+) |\u003e sq |\u003e print\n```\n\nFor multiline pipes, surround them with parenthesis (python rule that\nevery newline inside parenthesis is ignored):\n\n```coconut\n(\n    \"hello\"\n    |\u003e print\n)\n```\n\n-   pattern matching (`match x in value:`), guards\n-   algeabric data types\n-   partial application (`$` sign right after a function name)\n\n```elixir\nexpnums = map(pow$(2), range(5))\nexpnums |\u003e list |\u003e print\n```\n\n-   lazy lists (surround comma-separated lists with `(|` and `|)`)\n-   destructuring assignment\n-   function composition (with `..`)\n```livescript\nfog = f..g\n```\n-   prettier lambdas (`-\u003e` syntax)\n-   parallel programming\n-   tail recursion optimization\n-   infix notation (like in Haskell with backticks)\n-   underscore digits separators (`10_000_000`)\n-   decorators support any expression\n```\n@ wrapper1 .. wrapper2 $(arg)\n```\n-   code pass through the compiler\n-   ...\n\n### Install\n\n        pip install coconut\n\n### Editors\n\n-   Pygments support\n\nEditor |  \n--- | ---\nEmacs | https://github.com/NickSeagull/coconut-mode\nSublime | https://github.com/evhub/sublime-coconut\nVim | https://github.com/manicmaniac/coconut.vim\n\n\n## Hask -  Haskell language features and standard libraries in pure Python.\n\nHask |  \n--- | ---\nsources | [https://github.com/billpmurphy/hask](https://github.com/billpmurphy/hask)\ndoc | on github\nv1 ? | no\ncreated | july, 2015\n\nHask is a pure-Python, zero-dependencies library that mimics most of\nthe core language tools from Haskell, including:\n\n- **Full Hindley-Milner type system** (with typeclasses) that will typecheck any function decorated with a Hask type signature. Also, typed functions can be **partially applied**.\n```python\n@sig(H/ \"a\" \u003e\u003e \"b\" \u003e\u003e \"a\")\ndef const(x, y):\n    return x\n```\n- Easy creation of new **algebraic data types** and new typeclasses, with Haskell-like syntax\n- **Pattern matching** with case expressions\n```python\ndef fib(x):\n    return ~(caseof(x)\n                | m(0)   \u003e\u003e 1\n                | m(1)   \u003e\u003e 1\n                | m(m.n) \u003e\u003e fib(p.n - 1) + fib(p.n - 2))\n```\n- Automagical function **currying/partial application** and function composition\n- Efficient, **immutable, lazily evaluated** List type with Haskell-style list comprehensions\n- All your favorite syntax and control flow tools, including **operator sections**, **monadic error handling**, **guards**, and more\n- Python port of (some of) the standard libraries from Haskell's base, including:\n    - Algebraic datatypes from the Haskell Prelude, including Maybe and Either\n    - Typeclasses from the Haskell base libraries, including Functor, Applicative, Monad, Enum, Num, and all the rest\n    - Standard library functions from base, including all functions from Prelude, Data.List, Data.Maybe, and more\n\n\nFeatures not yet implemented, but coming soon:\n\n    - Python 3 compatibility\n    - Better support for polymorphic return values/type defaulting\n    - Better support for lazy evaluation (beyond just the List type and pattern matching)\n    - More of the Haskell standard library (Control.* libraries, QuickCheck, and more)\n    - Monadic, lazy I/O\n\n### Install\n\n    git clone https://github.com/billpmurphy/hask\n    python setup.py install\n\n\n## Rabbit - a functional language on top of Python (discontinued in favor of Coconut)\n\nRabbit |  \n------ | ----------------------------------------------------------------------\nsources |   [\u003chttps://github.com/evhub/rabbit\u003e](https://github.com/evhub/rabbit)\ndoc  | no doc\nv1 ?   |   yes, on oct, 2014. DISCONTINUED\ncreated |  v0.1 on may, 2014\n\nFrom the author's words:\n([src](https://www.reddit.com/r/Python/comments/4owzu7/coconut_functional_programming_in_python/d4hhfw0))\n\n\u003e Coconut is my attempt to fix the mistakes I thought I made with\n\u003e Rabbit, namely:\n\u003e\n\u003e -   Coconut is compiled, while Rabbit is interpreted, making Coconut\n\u003e     much faster\n\u003e -   Coconut is an extension to Python, while Rabbit is a replacement,\n\u003e     making Coconut much easier to use\n\nQuicksort:\n\n``` {.txt}\nqsort(l) = (\n    qsort: (as ~ \\x\\(x @ x\u003c=a)) ++ a ++ qsort: (as ~ \\x\\(x @ x\u003ea))\n    $ a,as = l\n    ) @ len:l\n```\n\n## MakrellPy - a functional language with metaprogramming support and simplistic syntax\n\n![](https://github.com/hcholm/makrell-py/blob/main/doc/makrell.png)\n\nMakrellPy |  \n--------|------------------------------------------------------------------------\nsources |  [\u003chttps://github.com/hcholm/makrell-py\u003e](https://github.com/hcholm/makrell-py)\nv1 ?    |  no\ncreated |  February, 2024\n\nMakrellPy, part of the Makrell language family, is a general-purpose, functional and homoiconic programming language with two-way Python interoperability, metaprogramming support and simple syntax. The language family is based on the Makrell Base Format, a general data format that can be used both for programming languages and data interchange. Other family members include MRON, a lightweight alternative to JSON, and MRML, a lightweight alternative to XML and HTML.\n\n### Language features\n\n- Compiles to Python AST, runs on Python with two-way interoperability.\n- Simple syntax using the Makrell Base Format.\n- Functional programming with multiline lambdas, partial application, and function composition.\n- Metaprogramming support with custom operators, macros and custom metaprogramming functions.\n- Homiconic, with a simple and consistent syntax for data and code.\n- Languages in the Makrell family can be embedded in each other while maintaining the base format.\n- The Makrell package includes MRON and MRML support, an API for working with the Makrell Base Format and a basic language server supporting the Language Server Protocol.\n- REPL, syntax highlighting and basic diagnostics support for Visual Studio Code.\n\n### Sample code\n```\n{fun add [x y]\n    x + y}\n\na = {add 2 3}\n{print a}  # 5\na | print  # same, with pipe operator\n\nf = [x y] -\u003e {do\n    {print \"multiline lambda here\"}\n    x * y\n}\n\n{print {f 2 3}}  # function call\n\nadd3 = {f 3 _}  # partial application\n\n2 | {+ 3} | {* 5}  # operators as functions\n\nadd3mul5 = add3 \u003e\u003e {* 5}  # function composition\n```\n\n### Install\n\n    pip install makrell\n\n### Editors\n\nEditor |  \n--- | ---\nVisual Studio Code | [\u003chttps://marketplace.visualstudio.com/items?itemName=hcholm.vscode-makrell\u003e](https://marketplace.visualstudio.com/items?itemName=hcholm.vscode-makrell)\nOther | MakrellPy is supported by the Language Server Protocol, so it should work with any editor that supports LSP.\n\n# Implemented in another language but target the Python platform. They can use Python libs.\n\n\n## Erg - General statically typed multiparadigm rusty programming language\n\n![](https://github.com/erg-lang/erg/blob/main/assets/erg_logo_with_slogan.svg)\n\n\u003e A statically typed language that can deeply improve the Python ecosystem \n\nErg |  \n--- | ---\nsources | [\u003chttps://github.com/erg-lang/erg\u003e](https://github.com/erg-lang/erg)\ndoc | [https://erg-lang.github.io/](https://erg-lang.github.io/)\nv1 ? | no, v0.4.2 as of September 2022\ncreated | 2022\n\nThe Erg compiler is written in Rust.\n\n### Language features\n\n\u003e Erg is a pure object-oriented language. Everything is an object; types, functions, and operators are all objects. On the other hand, Erg is also a functional language. Erg requires some kinds of markers to be placed on code that causes side effects or changes internal state, which can localize the complexity of code. This will greatly improve the maintainability of your code.\n\n\u003e Erg is internally compatible with Python and can import the Python API at zero cost.\n\n```python\n    # Functional style (immutable), same as `sorted(list)` in Python\n    immut_arr = [1, 3, 2]\n    assert immut_arr.sort() == [1, 2, 3]\n    # Object-oriented style (mutable)\n    mut_arr = ![1, 3, 2]\n    mut_arr.sort!()\n    assert mut_arr == [1, 2, 3]\n    i = !1\n    i.update! old -\u003e old + 1\n    assert i == 2\n\n    # Functions cannot cause side effects\n    inc i: Int! =\n        i.update! old -\u003e old + 1\n    # SyntaxError: cannot call a procedural method in a function\n    # hint: only methods of mutable types can change the state of objects\n\n    # Code that uses a lot of side effects is redundant, so you will naturally write pure code\n    Counter! = Inherit Int!\n    Counter!.\n        new i: Int = Self!::__new__ !i\n        inc! ref! self =\n            self.update! old -\u003e old + 1\n\n    c = Counter!.new 1\n    c.inc!()\n    assert c == 2\n```\n\n\n# Other languages that target the Python platform\n\n## Haxe, the cross-platform toolkit\n\nHaxe |  \n--- | ---\nsources | https://github.com/HaxeFoundation/haxe\nofficial website | https://haxe.org/\ndoc | https://haxe.org/documentation/introduction/\nonline REPL |_http://try.haxe.org/\nv1 ? | v3\n\nHaxe is an open source toolkit that allows you to easily build\ncross-platform tools and applications that target many mainstream\nplatforms (Python, ActionScript3, C++, C#, Flash, Java, Javascript,\nNekoVM, PHP, Lua).\n\n```haxe\nclass Test {\n  static function main() {\n    var people = [\n      \"Elizabeth\" =\u003e \"Programming\",\n      \"Joel\" =\u003e \"Design\"\n    ];\n    for (name in people.keys()) {\n      var job = people[name];\n      trace('$name does $job for a living!');\n    }\n  }\n}\n```\n# Domain-specific languages\n\n## ProbLog. Probabilistic Logic Programming.\n\nProbabilistic logic programs are logic programs in which some of the\nfacts are annotated with probabilities.\n\nProbLog |  \n--- | ---\nofficial website | https://dtai.cs.kuleuven.be/problog/\nsources | https://bitbucket.org/problog/problog\ndoc | http://problog.readthedocs.io/en/latest/\nv1 ? | yes, even v2\nonline tutorial and REPL | https://dtai.cs.kuleuven.be/problog/tutorial.html\n\nProbLog is built with Python. Its only requirement is Python2.7 or 3.\n\nOne can [interact with ProbLog from within Python code](http://problog.readthedocs.io/en/latest/python.html).\n\n### Install\n\n    pip install problog\n\n## PyDatalog. Logic programming to use inside your Python program.\n\nPyDatalog |  \n---       | ---\nofficial website | https://sites.google.com/site/pydatalog/\nsources          | https://github.com/pcarbonn/pyDatalog\ndoc              | https://sites.google.com/site/pydatalog/Online-datalog-tutorial\nv1 ?             | v0.17 (january, 2016)\nPyPy ?           | yes\n\npyDatalog adds the logic programming paradigm to Python. Logic\nprogrammers can now use the extensive standard library of Python, and\nPython programmers can now express complex algorithms quickly.\n\n\n```python\nfrom pyDatalog import pyDatalog\npyDatalog.create_terms('factorial, N')\n\n\nfactorial[N] = N*factorial[N-1]\n\nfactorial[1] = 1\n\nprint(factorial[3]==N)  # prints N=6\n```\n\n### Installation\n\n`pip install pyDatalog`\n`pip install sqlalchemy`\n\n### Example projects\n\nNo examples found, only\n[testimonials](https://sites.google.com/site/pydatalog/home/datalog-applications).\n\n\n## RBQL: SQL dialect with Python expressions\n\nRBQL |  \n---       | ---\nofficial website | https://rbql.org\nsources          | https://github.com/mechatroner/RBQL\nv1 ?             | no\nPyPy ?           | pip install rbql\n\nRBQL is both a library and a command line tool which provides SQL-like language with Python expressions  \nRBQL is integrated into \"Rainbow CSV\" text editor plugins available for VSCode, Vim, Sublime, Atom  \nMain Features:\n* Allows to use Python expressions inside _SELECT_, _UPDATE_, _WHERE_ and _ORDER BY_ statements\n* Result set of any query immediately becomes a first-class table on it's own\n* Works out of the box, no external dependencies\n\n#### Usage example:\n```python\nimport rbql\ninput_table = [\n    ['Roosevelt',1858,'USA'],\n    ['Napoleon',1769,'France'],\n    ['Dmitri Mendeleev',1834,'Russia'],\n    ['Jane Austen',1775,'England'],\n    ['Hayao Miyazaki',1941,'Japan'],\n]\nuser_query = 'SELECT a.name, \"birth century: {}\".format(a.DOB // 100 + 1) WHERE a.name == \"Roosevelt\" or re.search(\"an\", a.country, re.IGNORECASE) is not None ORDER BY random.random()'\noutput_table = []\nwarnings = []\nrbql.query_table(user_query, input_table, output_table, warnings, input_column_names=['name', 'DOB', 'country'])\nfor record in output_table:\n    print(','.join([str(v) for v in record]))\n```\n\n\n# Other languages built in RPython\n\n## Monte - secure distributed computation\n\nMonte is a \"nascent dynamic programming language reminiscent of Python\nand [E](http://erights.org/). It is based upon The Principle of Least\nAuthority (POLA), which governs interactions between objects, and a\ncapability-based object model, which grants certain essential safety\nguarantees to all objects\".\n\nMonte |  \n---   | ---\nSources | https://github.com/monte-language\nDoc     | https://monte.readthedocs.io/en/latest/intro.html\nv0.1 ?  | yes, v2016.1\n\nBuilt on Pypy.\n\n\n## Pixie, a lightweight and native lisp\n\nPixie |  \n--- | ---\nSources | https://github.com/pixie-lang/pixie\nDoc | Examples: https://github.com/pixie-lang/pixie/tree/master/examples\nv0.1 ? | no\nREPL, installer, test runner,… | https://github.com/pixie-lang/dust\nIRC | `#pixie-lang` on Freenode\n\nPixie is built in\n[RPython](https://pypy.readthedocs.io/en/latest/coding-guide.html),\nthe same language PyPy is written in, and as such \"supports a fairly\nfast GC and an amazingly fast tracing JIT\".\n\nInspired by Clojure.\n\n### Features\n\n- Immutable datastructures\n- Protocols first implementation\n- Transducers at-the-bottom (most primitives are based off of reduce)\n- A \"good enough\" JIT (implemented, tuning still a WIP, but not bad performance today)\n- Easy FFI\n- object system\n- continuations, async I/O inspired by nodejs (see talk)\n- Pattern matching (planned)\n\nFrom the FAQ:\n\n- Pixie implements its own virtual machine. It does not run on the\n  JVM, CLR or Python VM. It implements its own bytecode, has its own\n  GC and JIT. And it's small. Currently the interpreter, JIT, GC, and\n  stdlib clock in at about 10.3MB once compiled down to an executable.\n- The JIT makes some things fast. Very fast. Code like the following\n  compiles down to a loop with 6 CPU instructions. While this may not\n  be too impressive for any language that uses a tracing jit, it is\n  fairly unique for a language as young as Pixie.\n\n```lisp\n;;  This code adds up to 10000 from 0 via calling a function that takes a variable number of arguments.\n;;  That function then reduces over the argument list to add up all given arguments.\n\n(defn add-fn [\u0026 args]\n  (reduce -add 0 args))\n\n(loop [x 0]\n  (if (eq x 10000)\n    x\n    (recur (add-fn x 1))))\n```\n\n- Math system is fully polymorphic. Math primitives (+,-, etc.) are\n  built off of polymorphic functions that dispatch on the types of the\n  first two arguments. This allows the math system to be extended to\n  complex numbers, matrices, etc. The performance penalty of such a\n  polymorphic call is completely removed by the RPython generated JIT.\n\n### Good talks\n\n- [\"Pixie - A Lightweight Lisp with 'Magical' Powers\" by Timothy Baldridge on StrangeLoop, september 2015](https://www.youtube.com/watch?v=1AjhFZVfB9c)\n\n## RSqueak, a Squeak/Smalltalk VM written in RPython\n\nRSqueak |  \n--- | ---\nSources | https://github.com/HPI-SWA-Lab/RSqueak\nDoc | http://rsqueak.readthedocs.io\n\nwith all-in-one multiplatform bundles and 32 bits binaries.\n","funding_links":["https://github.com/sponsors/vindarel","https://ko-fi.com/vindarel"],"categories":["Others","Awesome Functional Python"],"sub_categories":["Languages"],"project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fvindarel%2Flanguages-that-compile-to-python","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fvindarel%2Flanguages-that-compile-to-python","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fvindarel%2Flanguages-that-compile-to-python/lists"}