{"id":25893153,"url":"https://github.com/apostolique/vyne-language","last_synced_at":"2026-02-16T06:03:09.719Z","repository":{"id":60479198,"uuid":"166800355","full_name":"Apostolique/Vyne-Language","owner":"Apostolique","description":"Definition for the Vyne Programming language.","archived":false,"fork":false,"pushed_at":"2023-11-20T00:55:36.000Z","size":195,"stargazers_count":9,"open_issues_count":0,"forks_count":0,"subscribers_count":5,"default_branch":"main","last_synced_at":"2025-10-06T20:47:02.652Z","etag":null,"topics":["language","programming-language","vyne"],"latest_commit_sha":null,"homepage":"https://apostolique.github.io/Vyne-Language/","language":null,"has_issues":false,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":"mit","status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/Apostolique.png","metadata":{"files":{"readme":"README.md","changelog":null,"contributing":null,"funding":".github/FUNDING.yml","license":"LICENSE","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},"funding":{"github":"apostolique"}},"created_at":"2019-01-21T11:09:43.000Z","updated_at":"2023-12-14T02:09:46.000Z","dependencies_parsed_at":"2023-11-14T21:27:06.451Z","dependency_job_id":"fedaef53-e816-4665-8a98-ffe266b0a871","html_url":"https://github.com/Apostolique/Vyne-Language","commit_stats":null,"previous_names":[],"tags_count":0,"template":false,"template_full_name":null,"purl":"pkg:github/Apostolique/Vyne-Language","repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/Apostolique%2FVyne-Language","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/Apostolique%2FVyne-Language/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/Apostolique%2FVyne-Language/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/Apostolique%2FVyne-Language/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/Apostolique","download_url":"https://codeload.github.com/Apostolique/Vyne-Language/tar.gz/refs/heads/main","sbom_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/Apostolique%2FVyne-Language/sbom","scorecard":null,"host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":286080680,"owners_count":29501366,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2026-02-16T05:57:17.024Z","status":"ssl_error","status_checked_at":"2026-02-16T05:56:49.929Z","response_time":115,"last_error":"SSL_connect returned=1 errno=0 peeraddr=140.82.121.5:443 state=error: unexpected eof while reading","robots_txt_status":"success","robots_txt_updated_at":"2025-07-24T06:49:26.215Z","robots_txt_url":"https://github.com/robots.txt","online":false,"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":["language","programming-language","vyne"],"created_at":"2025-03-02T21:30:34.791Z","updated_at":"2026-02-16T06:03:09.687Z","avatar_url":"https://github.com/Apostolique.png","language":null,"funding_links":["https://github.com/sponsors/apostolique"],"categories":[],"sub_categories":[],"readme":"# Vyne-Language\nDefinition for the Vyne Programming language. The Vyne language is an imaginary programming language. There are no known compilers that exist yet.\n\n## Discord\n\n[![Discord](https://img.shields.io/discord/530598289813536771.svg)](https://discord.gg/dHkA4bP)\n\n## Goals\n\n* The Vyne language is a general purpose programming language.\n* It should be cross-platform.\n* Compile parameters should be included within the source code.\n\n## Notes\n\nThe syntax shown in this document is tentative. Only used as a proof of concept.\n\n## Features\n\n### Comments\n\nSupport for single line comments and nested multiline comments.\n\nThe current syntax for single line comments:\n\n```csharp\n// Hello World!\n```\n\nThe current syntax for multiline comments:\n\n```rust\n/*\n    This is inside the comment\n    /*\n        You can insert something here.\n    */\n    This is a comment since the nested comment is parsed correctly.\n*/\n```\n\nThere is also a way to break out of nested comments:\n\n```rust\n/*\n    /*\n        /*\n            Comment here\n*//\n```\n\nLoose multiline comment terminators are ignored as whitespace:\n\n```\n*/*/*/\n```\n\n### Casting\n\nCasting is done after the value. Given two types `A` and `B` where `B` exposes a function called `Foo`.\n\n```csharp\nlet a: A;\n\na:B.Foo();\n```\n\n### Blocks\n\nThere are 3 different types of code blocks.\n\n#### :small_orange_diamond: Basic\n\nStarts a local scope. The scope is cleaned up when the end of the scope is reached.\n\n```\n{\n\n}\n```\n\n#### :small_orange_diamond: Deferred\n\nStarts a local scope. The scope is cleaned up when the parent scope is cleaned up.\n\n```rust\n{+\u003e\n\n}\n```\n\n#### :small_orange_diamond: Paralleled\n\nDoesn't start a new scope. Memory is cleaned up when the current scope is cleaned up. This block is brought to the top of the current scope to be executed first either sequencially or in parallel with the other parallel blocks in the scope.\n\n```rust\n{|\u003e\n\n}\n```\n\nCan be used like this:\n\n```rust\n{\n   let c = a + b;\n\n   {|\u003e\n      let a = 0;\n   }\n   {|\u003e\n      let b = 10;\n   }\n\n   {\n      let e = a + d;\n\n      {|\u003e\n         let d = 20 + c;\n      }\n   }\n}\n```\n\n### Block Chaining\n\nBlocks can be chained using the `else` and `then` keywords.\n\n#### :small_orange_diamond: Else\n\nThe `else` keyword is used to execute a block when the first block was not executed.\n\n```rust\n{\n    // This gets executed.\n}\nelse {\n    // This never gets executed.\n}\n```\n\n#### :small_orange_diamond: Then\n\nThe `then` keyword is used to always execute a block when the first block was executed.\n\n```vb\n{\n    // This gets executed.\n}\nthen {\n    // This gets executed.\n}\n```\n\n### Choices\n\n#### :small_orange_diamond: If\n\n```rust\nif condition {\n\n}\nelse if condition {\n\n}\nelse {\n\n}\n```\n\n#### :small_orange_diamond: Switch\n\nWorks like other languages. Will be closer to functional languages with pattern matching.\n\n### Loops\n\n#### :small_orange_diamond: Loop\n\nAn infinite loop that requires manual breaking out.\n\n```rust\nloop {\n\n}\n```\n\n#### :small_orange_diamond: While\n\nThe `while` loop has extra features compared to other languages.\n\n```rust\nwhile condition {\n\n}\nelse while condition {\n\n}\nelse loop {\n   if condition break;\n}\n```\n\nThe Vyne while loop works like an `if` statement.\n\nIt starts by checking the first condition. If it is true, it will enter that branch until the condition becomes false.\n\nIf the first condition was false, it will check the second condition. If it is true, it will enter that branch until the condition becomes false.\n\nIf the second condition was also false, it will execute the final else loop. The else loop here is an infinite loop that requires manual breaking out.\n\nThis new `while` loop can be mixed with other statements such as the `if` statement. It makes it possible to have this syntax:\n\n```rust\nif condition {\n\n}\nelse while condition {\n\n}\nelse if condition {\n\n}\nelse {\n\n}\n```\n\nOr to clean up after a loop:\n\n```rust\nwhile condition {\n\n}\nthen {\n    // Loop cleanup.\n}\nelse {\n    // The loop never got executed.\n}\n```\n\n#### :small_orange_diamond: For\n\nWorks like other languages.\n\n#### :small_orange_diamond: Do While\n\nCan be done using `loop`.\n\n```rust\nloop {\n    // Some code here.\n\n    if condition {\n        break;\n    }\n}\n```\n\n#### :small_orange_diamond: Foreach\n\nMost likely will work other languages.\n\n### General Statements\n\n#### :small_orange_diamond: Delay Expression\n\nThe delay expression is used to delay the execution of a block. It can be used to create code comments:\n\n```rust\n~{\n    // Some code.\n    // It will never be executed.\n    // Can be useful for code that you still want the compiler to check and throw errors on.\n    // It would be optimized out in the final assembly if the block isn't caught.\n}\n```\n\nIt is also possible to catch the definition in a variable to execute it later:\n\n```rust\nlet Point = ~{+\u003e\n    let X = 10;\n    let Y = 20;\n};\n\nlet a = Point!;\nlet b = Point!;\n\na.X = 15;\n```\n\nThis can be used to define reusable code.\n\nCan also be used like this:\n\n```rust\nlet a = ~1;\nlet b = a!;\n```\n\n#### :small_orange_diamond: Label\n\nIt is possible to add labels to some statements.\n\n```rust\nwhile :outer condition {\n    while :inner condition {\n\n    }\n}\n```\n\n#### :small_orange_diamond: Break\n\nA break is used to exit out of a loop.\n\n```rust\nloop {\n    break;\n}\n// We end up here after the break.\n```\n\nIn nested loops, it is possible to specify which loop to break out of using labels.\n\n```rust\nwhile :outer condition {\n    while :middle condition {\n        while :inner condition {\n            break middle;\n        }\n    }\n    // We end up here after the break.\n}\n```\n\n#### :small_orange_diamond: Continue\n\nA continue is used to skip to the end of a loop iteration.\n\n```rust\nwhile condition {\n    continue;\n\n    // Some code that is never reached.\n\n    // We end up here after the continue.\n}\n```\n\nThe continue can also be used with labels.\n\n```rust\nwhile :outer condition {\n    while :middle condition {\n        while :inner condition {\n            continue middle;\n        }\n        // We end up here after the continue.\n    }\n}\n```\n\n### Subroutines\n\n#### :small_orange_diamond: Function\n\nDoesn't have the ability to produce side effects. Takes read-only input parameters and returns write-only output parameters. If the same variable is passed as an input and output, then some optimizations can be applied. For example a variable could end up being passed as a reference, or it could be passed by value with deep copy. Control flow is returned back to the caller.\n\nFor example, the following function takes 1 input variable and returns 1 output variable:\n\n```rust\nlet a = 1;\n\nlet addTwo = ~{\n    in b += 2;\n    out b;\n}\n\nlet c = addTwo(a)!;\n```\n\nThe original variable `a` is not modified. It is passed by value.\n\nThe variable `c` is write-only from the function's point of view.\n\n```rust\nlet a = 1;\n\nlet addTwo = ~{\n    in b += 2;\n    out b;\n}\n\na = addTwo(a)!;\n```\n\nIn the example above, the caller gives explicit permission to the function to modify `a`. As such it is passed by reference.\n\n```rust\nlet a = 1;\nlet b = 2;\n\nlet swap = ~{\n    in c, d;\n    out d, c;\n}\n\na, b = swap(a, b)!;\n```\n\nThis last one could be used to swap variables.\n\nCombined with the delay expression and a deferred block, it's possible to get something similar to a class.\n\n```rust\nlet Point = ~{+\u003e\n    in X;\n    in Y;\n};\n\nlet a = Point(10, 20)!;\n```\n\n### Boolean operators\n\nCurrently proposed boolean operators:\n\n```\n==\n!=\n\u003c\n\u003e\n\u003c=\n\u003e=\n!\u003c\n!\u003e\n```\n\n`!\u003c` and `!\u003e` are equivalent to `\u003e=` and `\u003c=`. In some cases, it is useful to represent logic using one or the other to make an algorithm's purpose clearer.\n\nBoolean operators have syntactic sugar to make it easier to write common logic using `\u0026` and `|`:\n\n```\n0 \u003c i \u0026\u003c 10\nbecomes\n0 \u003c i \u0026\u0026 i \u003c 10\n```\n```\n0 \u003c i |\u003c 10\nbecomes\n0 \u003c i || i \u003c 10\n```\n\n### Scope\n\nThe concept of a scope is very important in the Vyne language. Where does something exist? Where something lives needs to always be explicit. A global variable would only be a variable that is made explicitly accessible within other scopes. It is possible to name scopes and pass them as function parameters.\n\n#### Scope dependency\n\nIt is possible to define a scope as dependent on external factors. This makes it possible for a scope to access variables that are external to itself. It's up to the parent scope to satisfy those dependencies.\n","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fapostolique%2Fvyne-language","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fapostolique%2Fvyne-language","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fapostolique%2Fvyne-language/lists"}