Rune is a programming language developed to test ideas for improving security and efficiency.

Overview

ᚣ The Rune Programming Language

Safer code for secure enclaves

This is not an officially supported Google product.

NOTE: Rune is an unfinished language. Feel free to kick tires and evaluate the cool new security and efficiency features of Rune, but, for now, it is not recommended for any production use case.

Rune is a systems programming language designed for security-sensitive applications. Rune can help you avoid common security flaws that often arise when using traditional systems languages such as C and C++. Its primary goal is providing safety features for hardware-enforced private computation such as sealed computation or secure enclaves. Rune's most notable security feature is constant-time processing of secrets. Rune also aims to be faster than C++ for most memory-intensive applications, due to its Structure-of-Array (SoA) memory management.

For more information about Rune, see additional documentation in g3doc.

Compiling the Rune compiler:

You'll need 6 dependencies installed to compile Rune:

  • Bison (parser generator)
  • Flex (lexer generator)
  • GNU multi-precision package gmp
  • Clang version 10
  • Datadraw, an SoA data-structure generator for C
  • CTTK, a constant-time big integer arithmetic library The first four can be installed with one command:
$ sudo apt-get install bison flex libgmp-dev clang-10

Installing Datadraw requires cloning the source from github, or getting it from //third_party/datadraw.

$ git clone https://github.com/waywardgeek/datadraw.git
$ sudo apt-get install build-essential
$ cd datadraw
$ ./autogen.sh
$ ./configure
$ make
$ sudo make install

Hopefully that all goes well... After dependencies are installed, to build rune:

$ git clone https://github.com/google/rune.git
$ git clone https://github.com/pornin/CTTK.git
$ cp CTTK/inc/cttk.h CTTK
$ cd rune
$ make

CTTK was written by Thomas Pornin. It provides constant-time big-integer arithmetic.

If make succeeds, test the Rune compiler in the rune directory with:

$ ./runtests.sh

Some tests are currently expected to fail, but most should pass. To install rune under /usr/local/rune:

$ sudo make install

Test your installation:

$ echo 'println "Hello, World!"' > hello.rn
$ rune -g hello.rn
$ ./hello

You can debug your binary executable with gdb:

$ gdb ./hello

TODO: add instructions on how to debug compiler itself, especially the datadraw debug functionality.

Comments
  • Fixed-size array allocation and fixed-size types

    Fixed-size array allocation and fixed-size types

    I see there is a method allocArrayBuffer in the runtime, but looking through every test in /tests and /newtests, I couldn't find some usage of code like:

    std::byte buffer[4096];
    

    I tried the below on a guess, but this was not valid rune:

    myArray = [u32; 4096]
    
    opened by GavinRay97 5
  • Enhance README organization, add more background info to code

    Enhance README organization, add more background info to code

    Heya,

    When I first read the Rune readme, there were a couple of things I thought could be improved:

    • I didn't understand where methods like appendMotheredHuman etc come from. We "magically" have access to something we didn't define and it feels strange. It gets described later on, but it would have been nice for a comment to say "Hey, don't worry! I'll explain why this magic-method exists in a little bit!"
    • DataDraw doesn't get mentioned, and I had to piece the connection together myself. In my opinion, a HUGE amount of appeal comes from the fact that DD is integrated into Rune, and it's very interesting + explains much of the behavior and design decisions/architecture + performance.

    Also, many people will want to jump directly to specific things ("how do I build this?", "show me a code example?") without reading the rest of it, so I tried to add enough context to each section that it would make sense if you went straight there and skipped the rest.

    Lastly, I added some organizational structure and a TOC so folks can navigate the page easier.

    Hope this is helpful, I'd like to highlight Rune in the best way possible for potential users as I think it has some neat ideas 🙂


    Ahh, one last thing -- I chose the languages for the syntax highlighting for each code block based on which one looked the best/could highlight the majority of the tokens:

    Go:

    // Check the MAC (message authentication code) for a message.  A MAC is derived
    func checkMac(macSecret: secret(string), message: string, mac: string) -> bool {
        computedMac = computeMac(macSecret, message)
        return mac == computedMac
    }
    

    Rust (TypeScript comes close too, but not quite as good):

    class Human(self: Human, name: string, mother: Human? = null(self), father: Human? = null(self)) {
      self.name = name
      if !isnull(mother) {
        mother.appendMotheredHuman(self)
      }
    }
    
    opened by GavinRay97 4
  • [SUP] hashValues fails to compile

    [SUP] hashValues fails to compile

    I followed the "Compiling the Rune compiler" from the readme and it all finally compiled and didn't complain😅 Then I tried to run the tests and saw

    /tmp/nullindirection-c4ad80.o: In function `hashValues':
    /projects/rune/builtin/hashed.rn:17: undefined reference to `llvm.fshr.i64'
    clang: error: linker command failed with exit code 1 (use -v to see invocation)
    ./runl: line 6: ./errortests/nullindirection: No such file or directory
    ....
    Passed: 39
    Failed: 185
    

    I tried to compile a hello world program I got the same error Also I found that by using -b flag program was able to compile


    • rune: Current main
    • os: Ubuntu 18.04.5 LTS bionic on Windows 10 x86_64
    • clang: version 6.0.0-1ubuntu2 (tags/RELEASE_600/final) Target: x86_64-pc-linux-gnu Thread model: posix InstalledDir: /usr/bin
    opened by 0dminnimda 3
  • fix error compiling test/basecaselast.rn

    fix error compiling test/basecaselast.rn

    The test failed when runtests.sh is executed.

    I fixed it by referring to here. https://github.com/google/rune/blob/main/doc/rune4python.md#recursion

    The following PR was withdrawn because it had two commit logs. https://github.com/google/rune/pull/16

    opened by HAYASAKA-Ryosuke 3
  • Probably missing dependency during installation

    Probably missing dependency during installation

    Following the installation instructions in the README, during the "building rune"-step, I ran into a missing prerequisite. The make command in

    $ git clone https://github.com/google/rune.git
    $ git clone https://github.com/pornin/CTTK.git
    $ cp CTTK/inc/cttk.h CTTK
    $ cd rune
    $ make
    

    resulted in

    clang -Wall -g -std=c11 -Wno-varargs -I../../CTTK -DRN_DEBUG -c array.c bigint.c io.c random.c
    make[1]: clang: No such file or directory
    

    This was off course easy fixable by installing clang. But since especially clang-14 is specifically stated as prerequisite I wondered if this list is incomplete and clang should be added to the instructions, specifically expanding

    $ sudo apt-get install bison flex libgmp-dev clang-14
    

    to

    $ sudo apt-get install bison flex libgmp-dev clang clang-14
    

    or if this was a problem on my site. Happy to give further information or to extend the README.

    opened by RuneDominik 2
  • invalid trunc should throw

    invalid trunc should throw

    errortests/trunc.rn fails with a var (and also a constant)

    variable should add a runtime truncation check:

    %2 = trunc i64 %1 to i16, !dbg !208
    ; missing %1 vs %2 check
    

    constant may throw directly at compile-time:

    println "%x16" % <u16>0xdeadbeef =>
    %1 = trunc i64 3735928559 to i16, !dbg !205
    
    diff --git llvm/genllvm.c llvm/genllvm.c
    index a9fff61..245cb0d 100644
    --- llvm/genllvm.c
    +++ llvm/genllvm.c
    @@ -1490,6 +1490,8 @@ static llElement resizeSmallInteger(llElement element, uint32 newWidth, bool isS
       char *operation;
       if (newWidth < oldWidth) {
         operation = "trunc";
    +    //TODO if constant throw error if truncation looses info.
    +    //     else if not constant add code to check at run-time.
       } else {
         deDatatypeType type = deDatatypeGetType(oldDatatype);
         if (type == DE_TYPE_INT) {
    

    See also: https://cwe.mitre.org/data/definitions/197.html

    opened by rurban 2
  • Clear up Rune-for-Python documentation

    Clear up Rune-for-Python documentation

    Just a bunch of tiny adjustments (the commit history is hopefully descriptive enough!), with some examples stemming from recent additions to the Python language added.

    opened by alexpovel 2
  • Add Dockerfile that builds rune/datadraw

    Add Dockerfile that builds rune/datadraw

    (Note: I intend to add/update the docs for this feature, after the other PR I have for docs is either merged or rejected)

    With this Dockerfile, it's possible to build the compiler by just running:

    $ docker build -t rune-compiler:latest .
    

    You can then compile rune files like this:

    $ echo 'println "Hello, World!"' > hello.rn
    $ docker run -v $(pwd):/tmp rune-compiler rune -g /tmp/hello.rn
    
    $ ls | grep hello
    hello
    hello.ll
    hello.rn
    
    $ ./hello
    Hello, World!
    

    It's also possible to use this as a hermetic/reproducible environment to build the compiler/core libs, and then copy them into your host machine:

    $ docker run -i -v $(pwd)/rune:/tmp rune-compiler:latest sh << COMMANDS
      cp -r /usr/local/bin /tmp
      cp -r /usr/local/lib/rune /tmp/lib
    COMMANDS
    
    $ tree rune -L 2
    rune
    ├── bin
    │   ├── datadraw
    │   ├── dataview
    │   └── rune
    └── lib
        ├── builtin
        ├── io
        ├── libcttk.a
        ├── librune.a
        ├── math
        └── runtime
    
    $ ./rune --help
    Usage: rune [options] file
        -b        - Don't load bulitin Rune files.
        -g        - Include debug information for gdb.  Implies -l.
        -l <llvmfile> - Write LLVM IR to <llvmfile>.
        -n        - No clang.  Don't compile the resulting .ll output.
        -O        - Optimized build.  Passes -O3 to clang.
        -p <dir>  - Use <dir> as the root directory for packages.
        -t        - Execute unit tests for all modules.
        -U        - Unsafe mode.  Don't generate bounds checking, overflow
                    detection, and destroyed object access detection.
        -x        - Invert the return code: 0 if we fail, and 1 if we pass.
        -X        - Use the new event driven binder.
    
    opened by GavinRay97 0
  • [ENH] Add gitignore

    [ENH] Add gitignore

    While trying to compile the rune, I was surprised to see that a lot junk of files were picked up by git I think it makes sense to ignore these files, especially the compiled binary files

    opened by 0dminnimda 0
  • Fixed typo in Readme.md: fater -> father

    Fixed typo in Readme.md: fater -> father

    There was a minor typo in the Readme.md in two places I fixed. The PR https://github.com/google/rune/pull/4 also solves one of the places but not the other.

    opened by roydigerhund 0
  • update README.md

    update README.md

    Minor updates to the README:

    • Bold and shorten the warning about using Rune in production.
    • Minor editorial, sentence-level changes in the description of the language
    • Update list of dependencies to enumerate all six major dependencies. Reorder the list so that the statement about installing "the first four" makes more sense.
    • Use code fencing syntax instead of tabs, mark the language as shell (sh).
    opened by scolsen 0
  • Relevance to Nim

    Relevance to Nim

    This looks a hell lot like an already existing language, called Nim

    Python like syntax with C/C++ interop, reference counting and so on.

    Did you take any inspiration? https://nim-lang.org/

    And what would you say, are Rune's benefits, compared to it?

    opened by ShalokShalom 2
  • Doubly linked relation?

    Doubly linked relation?

    In the class example in the README, the Human class adds self to mother and father. However it does not add mother and father anywhere into self, which is what I would expect with "DoublyLinked." What does it mean?

    opened by jgarvin 1
  • Grammar railroad diagram

    Grammar railroad diagram

    Using some online tools like https://www.bottlecaps.de/rr/ui and https://www.bottlecaps.de/convert/ and a bit of manual fixes we can have a nice navigable railroad diagram.

    Copy and paste the EBNF shown bellow on https://www.bottlecaps.de/rr/ui on the tab Edit Grammar the click on the tab View Diagram to see/download a navigable railroad diagram.

    /* converted on Sun Nov 27, 2022, 10:23 (UTC+01) by bison-to-w3c v0.62 which is Copyright (c) 2011-2022 by Gunther Rademacher <[email protected]> */
    
    goal     ::= initialize optNewlines runeFile
    initialize
             ::=
    runeFile ::= statements
    statements
             ::= statement*
    statement
             ::= appendCode
               | assertStatement
               | assignmentStatement
               | callStatement
               | class
               | debugStatement
               | enum
               | externFunction
               | finalFunction
               | foreachStatement
               | forStatement
               | function
               | generateStatement
               | generatorStatement
               | ifStatement
               | import
               | prependCode
               | printlnStatement
               | printStatement
               | refStatement
               | relationStatement
               | returnStatement
               | struct
               | switchStatement
               | throwStatement
               | unitTestStatement
               | unrefStatement
               | whileStatement
               | yield
    import   ::= ( ( KWIMPORT | KWIMPORTLIB | KWIMPORTRPC ) pathExpressionWithAlias | KWUSE IDENT ) newlines
    class    ::= ( classHeader | exportClassHeader ) '(' oneOrMoreParameters ')' block
    classHeader
             ::= KWCLASS IDENT optWidth
    optWidth ::= ( ':' UINTTYPE )?
    exportClassHeader
             ::= ( KWEXPORT | KWEXPORTLIB | KWRPC ) KWCLASS IDENT optWidth
    struct   ::= structHeader '{' newlines ( structMember newlines )* '}' newlines
               | exportStructHeader block
    structHeader
             ::= KWSTRUCT IDENT
    structMember
             ::= optConst IDENT optTypeExpression optInitializer
    optConst ::= KWCONST?
    optInitializer
             ::= ( '=' expression )?
    exportStructHeader
             ::= ( KWEXPORT | KWEXPORTLIB ) KWSTRUCT IDENT
    appendCode
             ::= appendCodeHeader block
    appendCodeHeader
             ::= KWAPPENDCODE pathExpression?
    prependCode
             ::= prependCodeHeader block
    prependCodeHeader
             ::= KWPREPENDCODE pathExpression?
    block    ::= '{' newlines statements '}' optNewlines
    function ::= ( functionHeader | exportFunctionHeader | rpcHeader ) '(' parameters ')' optFuncTypeExpression block
    functionHeader
             ::= ( KWFUNC | KWITERATOR ) IDENT
               | KWOPERATOR operator
    operator ::= '+'
               | '-'
               | '*'
               | '/'
               | '%'
               | KWAND
               | KWOR
               | KWXOR
               | '&'
               | '|'
               | '@'
               | '^'
               | KWSHL
               | KWSHR
               | KWROTL
               | KWROTR
               | KWADDTRUNC
               | KWSUBTRUNC
               | KWMULTRUNC
               | '~'
               | '<'
               | KWLE
               | '>'
               | KWGE
               | KWEQUAL
               | KWNOTEQUAL
               | '!'
               | '[' ']'
               | KWIN
    exportFunctionHeader
             ::= ( KWEXPORT ( KWFUNC | KWITERATOR ) | KWEXPORTLIB KWFUNC ) IDENT
    parameters
             ::= oneOrMoreParameters?
    oneOrMoreParameters
             ::= parameter ( ',' optNewlines parameter )*
    parameter
             ::= optVar ( IDENT | '<' IDENT '>' ) optTypeExpression
               | initializedParameter
    optVar   ::= KWVAR?
    initializedParameter
             ::= optVar ( IDENT | '<' IDENT '>' ) optTypeExpression '=' expression
    externFunction
             ::= ( KWEXTERN STRING functionHeader | rpcHeader ) '(' parameters ')' optFuncTypeExpression newlines
    rpcHeader
             ::= KWRPC IDENT
    ifStatement
             ::= ifPart elseIfPart* optElsePart
    ifPart   ::= ifStatementHeader expression block
    ifStatementHeader
             ::= KWIF
    elseIfPart
             ::= elseIfStatementHeader expression block
    elseIfStatementHeader
             ::= KWELSE KWIF
    optElsePart
             ::= elsePart?
    elsePart ::= elseStatementHeader block
    elseStatementHeader
             ::= KWELSE
    switchStatement
             ::= switchStatementHeader expression switchBlock
    switchStatementHeader
             ::= KWSWITCH
    switchBlock
             ::= '{' newlines switchCase* optDefaultCase '}' optNewlines
    switchCase
             ::= KWCASE expression ( ',' optNewlines expression )* block
    optDefaultCase
             ::= ( defaultCaseHeader block )?
    defaultCaseHeader
             ::= KWDEFAULT
    whileStatement
             ::= optDoStatement whileStatementHeader expression ( newlines | block )
    whileStatementHeader
             ::= KWWHILE
    optDoStatement
             ::= doStatement?
    doStatement
             ::= doStatementHeader block
    doStatementHeader
             ::= KWDO
    forStatement
             ::= forStatementHeader nonConstAssignmentExpression ',' optNewlines expression ',' optNewlines nonConstAssignmentExpression block
    forStatementHeader
             ::= KWFOR
    assignmentStatement
             ::= assignmentExpression newlines
    assignmentExpression
             ::= KWCONST? nonConstAssignmentExpression
    nonConstAssignmentExpression
             ::= accessExpression optTypeExpression assignmentOp expression
    assignmentOp
             ::= '='
               | KWADDEQUALS
               | KWSUBEQUALS
               | KWMULEQUALS
               | KWDIVEQUALS
               | KWMODEQUALS
               | KWBITANDEQUALS
               | KWBITOREQUALS
               | KWBITXOREQUALS
               | KWANDEQUALS
               | KWOREQUALS
               | KWXOREQUALS
               | KWEXPEQUALS
               | KWSHLEQUALS
               | KWSHREQUALS
               | KWROTLEQUALS
               | KWROTREQUALS
               | KWADDTRUNCEQUALS
               | KWSUBTRUNCEQUALS
               | KWMULTRUNCEQUALS
    optTypeExpression
             ::= ( ':' expression )?
    optFuncTypeExpression
             ::= ( KWARROW expression )?
    accessExpression
             ::= tokenExpression ( '(' callParameterList ')' | '.' IDENT | '[' expression ( ':' expression )? ']' )*
    callStatement
             ::= accessExpression '(' callParameterList ')' newlines
    callParameterList
             ::= ( callParameter ( ',' optNewlines callParameter )* optComma )?
    callParameter
             ::= ( IDENT '=' )? expression
    optComma ::= ','?
    printStatement
             ::= KWPRINT expressionList newlines
    printlnStatement
             ::= KWPRINTLN expressionList newlines
    throwStatement
             ::= KWTHROW expressionList newlines
    assertStatement
             ::= KWASSERT expressionList newlines
    returnStatement
             ::= KWRETURN expression? newlines
    generatorStatement
             ::= generatorHeader '(' parameters ')' block
    generatorHeader
             ::= KWGENERATOR IDENT
    generateStatement
             ::= KWGENERATE pathExpression '(' expressionList ')' newlines
    relationStatement
             ::= KWRELATION pathExpression pathExpression optLabel pathExpression optLabel optCascade optExpressionList newlines
    optLabel ::= ( ':' STRING )?
    optCascade
             ::= KWCASCADE?
    optExpressionList
             ::= ( '(' expressionList ')' )?
    yield    ::= KWYIELD expression newlines
    unitTestStatement
             ::= unitTestHeader block
    unitTestHeader
             ::= KWUNITTEST IDENT
    debugStatement
             ::= debugHeader block
    debugHeader
             ::= KWDEBUG
    enum     ::= enumHeader '{' newlines entry+ '}' newlines
    enumHeader
             ::= KWENUM IDENT
    entry    ::= IDENT ( '=' INTEGER )? newlines
    foreachStatement
             ::= forStatementHeader IDENT KWIN expression block
    finalFunction
             ::= finalHeader '(' parameter ')' block
    finalHeader
             ::= KWFINAL
    refStatement
             ::= KWREF expression newlines
    unrefStatement
             ::= KWUNREF expression newlines
    expressionList
             ::= oneOrMoreExpressions?
    oneOrMoreExpressions
             ::= expression ( ',' optNewlines expression )*
    expression
             ::= dotDotDotExpression
    dotDotDotExpression
             ::= selectExpression ( KWDOTDOTDOT selectExpression )?
    selectExpression
             ::= orExpression ( '?' orExpression ':' orExpression )?
    orExpression
             ::= xorExpression ( KWOR xorExpression )*
    xorExpression
             ::= andExpression ( KWXOR andExpression )*
    andExpression
             ::= inExpression ( KWAND inExpression )*
    inExpression
             ::= modExpression ( KWIN modExpression )?
    modExpression
             ::= relationExpression ( KWMOD bitorExpression )?
    relationExpression
             ::= bitorExpression ( ( '<' | KWLE | '>' | KWGE | KWEQUAL | KWNOTEQUAL ) bitorExpression )?
    bitorExpression
             ::= bitxorExpression ( '|' bitxorExpression )*
    bitxorExpression
             ::= bitandExpression ( '@' bitandExpression )*
    bitandExpression
             ::= shiftExpression ( '&' shiftExpression )*
    shiftExpression
             ::= addExpression ( ( KWSHL | KWSHR | KWROTL | KWROTR ) addExpression )?
    addExpression
             ::= KWSUBTRUNC? mulExpression ( ( '+' | '-' | KWADDTRUNC | KWSUBTRUNC ) mulExpression )*
    mulExpression
             ::= prefixExpression ( ( '*' | '/' | '%' | KWMULTRUNC ) prefixExpression )*
    prefixExpression
             ::= postfixExpression ( '^' postfixExpression )*
               | ( '!' | '~' | '-' | ( '<' | KWCASTTRUNC ) prefixExpression '>' ) prefixExpression
    postfixExpression
             ::= accessExpression
               | '&' pathExpression '(' expressionList ')'
    tokenExpression
             ::= IDENT
               | STRING
               | INTEGER
               | FLOAT
               | RANDUINT
               | BOOL
               | '[' oneOrMoreExpressions ']'
               | ( KWSECRET | KWREVEAL | KWARRAYOF | KWTYPEOF | KWUNSIGNED | KWSIGNED | KWWIDTHOF | KWISNULL )? '(' expression ')'
               | tupleExpression
               | KWNULL
               | typeLiteral
    typeLiteral
             ::= UINTTYPE
               | INTTYPE
               | KWSTRING
               | KWBOOL
               | KWF32
               | KWF64
    pathExpression
             ::= IDENT ( '.' IDENT )*
    pathExpressionWithAlias
             ::= pathExpression ( KWAS IDENT )?
    tupleExpression
             ::= '(' expression ( ( ',' optNewlines expression )+ optComma | ',' ) ')'
    optNewlines
             ::= '\n'*
    newlines ::= ( '\n' | ';' )+
    
    //
    // Tokens
    //
    
    // <INITIAL>\("[^"]+"\)\s+{.+?return \([^;]+\); }  -> \2 ::= \1
    
    KWAPPENDCODE ::= "appendcode"
    KWARRAYOF ::= "arrayof"
    KWAS ::= "as"
    KWASSERT ::= "assert"
    KWBOOL ::= "bool"
    KWCASCADE ::= "cascade"
    KWCASE ::= "case"
    KWCLASS ::= "class"
    KWCONST ::= "const"
    KWDEBUG ::= "debug"
    KWDEFAULT ::= "default"
    KWDO ::= "do"
    KWELSE ::= "else"
    KWENUM ::= "enum"
    KWEXPORT ::= "export"
    KWEXPORTLIB ::= "exportlib"
    KWRPC ::= "rpc"
    KWEXTERN ::= "extern"
    BOOL ::= "false"
    KWFINAL ::= "final"
    KWFOR ::= "for"
    KWFUNC ::= "func"
    KWGENERATE ::= "generate"
    KWGENERATOR ::= "generator"
    KWIF ::= "if"
    KWIMPORT ::= "import"
    KWIMPORTLIB ::= "importlib"
    KWIMPORTRPC ::= "importrpc"
    KWIN ::= "in"
    KWISNULL ::= "isnull"
    KWITERATOR ::= "iterator"
    KWMOD ::= "mod"
    KWNULL ::= "null"
    KWOPERATOR ::= "operator"
    KWPREPENDCODE ::= "prependcode"
    KWPRINT ::= "print"
    KWPRINTLN ::= "println"
    KWREF ::= "ref"
    KWRELATION ::= "relation"
    KWRETURN ::= "return"
    KWREVEAL ::= "reveal"
    KWSECRET ::= "secret"
    KWSIGNED ::= "signed"
    KWSTRING ::= "string"
    KWSTRUCT ::= ("struct"|"message")
    KWSWITCH ::= "switch"
    KWTHROW ::= "throw"
    BOOL ::= "true"
    KWTYPEOF ::= "typeof"
    KWUNITTEST ::= "unittest"
    KWUNREF ::= "unref"
    KWUNSIGNED ::= "unsigned"
    KWUSE ::= "use"
    KWVAR ::= "var"
    KWWHILE ::= "while"
    KWWIDTHOF ::= "widthof"
    KWYIELD ::= "yield"
    
    KWADDEQUALS ::= "+="
    KWADDTRUNCEQUALS ::= "!+="
    KWADDTRUNC ::= "!+"
    KWANDEQUALS ::= "&&="
    KWBITANDEQUALS ::= "&="
    KWAND ::= "&&"
    KWARROW ::= "->"
    KWCASTTRUNC ::= "!<"
    KWDIVEQUALS ::= "/="
    KWDOTDOTDOT ::= "..."
    KWEQUAL ::= "=="
    KWEXPEQUALS ::= "^="
    KWGE ::= ">="
    KWLE ::= "<="
    KWMODEQUALS ::= "%="
    KWMULEQUALS ::= "*="
    KWMULTRUNCEQUALS ::= "!*="
    KWMULTRUNC ::= "!*"
    KWNOTEQUAL ::= "!="
    KWBITOREQUALS ::= "|="
    KWOREQUALS ::= "||="
    KWOR ::= "||"
    KWROTLEQUALS ::= "<<<="
    KWROTL ::= "<<<"
    KWROTREQUALS ::= ">>>="
    KWROTR ::= ">>>"
    KWSHLEQUALS ::= "<<="
    KWSHL ::= "<<"
    KWSHREQUALS ::= ">>="
    KWSHR ::= ">>"
    KWSUBEQUALS ::= "-="
    KWSUBTRUNCEQUALS ::= "!-="
    KWSUBTRUNC ::= "!-"
    KWBITXOREQUALS ::= "@="
    KWXOREQUALS ::= "@@="
    KWXOR ::= "@@"
    KWF32 ::= "f32"
    KWF64 ::= "f64"
    
    opened by mingodad 2
Owner
Google
Google ❤️ Open Source
Google
New ultra super robust and fast programming language, fully supportable by G++ and Clang

Cplusplusplus New ultra super robust and fast programming language, fully supportable by G++ and Clang How to use: Just write #include <C+++.h> in you

Vladimir Melnikov 1 Nov 29, 2021
Cinder is a community-developed, free and open source library for professional-quality creative coding in C++.

Cinder 0.9.3dev: libcinder.org Cinder is a peer-reviewed, free, open source C++ library for creative coding. Please note that Cinder depends on a few

Cinder 5k Jan 7, 2023
A program developed using MPI for distributed computation of Histogram for large data and their performance anaysis on multi-core systems

mpi-histo A program developed using MPI for distributed computation of Histogram for large data and their performance anaysis on multi-core systems. T

Raj Shrestha 2 Dec 21, 2021
Deep Learning in C Programming Language. Provides an easy way to create and train ANNs.

cDNN is a Deep Learning Library written in C Programming Language. cDNN provides functions that can be used to create Artificial Neural Networks (ANN)

Vishal R 12 Dec 24, 2022
Deep Scalable Sparse Tensor Network Engine (DSSTNE) is an Amazon developed library for building Deep Learning (DL) machine learning (ML) models

Amazon DSSTNE: Deep Scalable Sparse Tensor Network Engine DSSTNE (pronounced "Destiny") is an open source software library for training and deploying

Amazon Archives 4.4k Dec 30, 2022
Learning Programming C Language

Learning-Programming-C Learning Programming C Language Question 1 Have the computer print HI, HOW OLD ARE YOU? on one line. The user then enters his o

null 4 Dec 8, 2022
Adorad - Fast, Expressive, & High-Performance Programming Language for those who dare

The Adorad Language Adorad | Documentation | Contributing | Compiler design Key Features of Adorad Simplicity: the language can be learned in less tha

Adorad 54 Dec 26, 2022
Super Mario Remake using C++, SFML, and Image Processing which was a project for Structure Programming Course, 1st Year

Super Mario Remake We use : C++ in OOP concepts SFML for game animations and sound effects. Image processing (Tensorflow and openCV) to add additional

Omar Elshopky 5 Dec 11, 2022
Mobile Robot Programming Toolkit (MRPT) provides C++ libraries aimed at researchers in mobile robotics and computer vision

The MRPT project 1. Introduction Mobile Robot Programming Toolkit (MRPT) provides C++ libraries aimed at researchers in mobile robotics and computer v

MRPT 1.6k Dec 24, 2022
Code and Data for our CVPR 2021 paper "Structured Scene Memory for Vision-Language Navigation"

SSM-VLN Code and Data for our CVPR 2021 paper "Structured Scene Memory for Vision-Language Navigation". Environment Installation Download Room-to-Room

hanqing 35 Dec 3, 2022
Triton - a language and compiler for writing highly efficient custom Deep-Learning primitives.

Triton - a language and compiler for writing highly efficient custom Deep-Learning primitives.

OpenAI 4.6k Dec 26, 2022
Episodic Transformer (E.T.) is a novel attention-based architecture for vision-and-language navigation.

Episodic Transformer (E.T.) is a novel attention-based architecture for vision-and-language navigation. E.T. is based on a multimodal transformer that encodes language inputs and the full episode history of visual observations and actions.

Alex Pashevich 61 Nov 17, 2022
Repository for material related to the Programming Languages Virtual Meetup coverage of the Category Theory for Programmers book.

CTfP-2021 This is the material (code and presentation slide decks) that correspond to the Programming Languages Virtual Meetup course that is covering

Conor Hoekstra 119 Dec 5, 2022
Simple samples for TensorRT programming

Introduction This is a collection of simplified TensorRT samples to get you started with TensorRT programming. Most of the samples are written in C++,

NVIDIA Corporation 675 Jan 6, 2023
The code for C programming 2021, Department of Computer Science, National Taiwan University.

C2021 .c for sousce code, .in for input file, and .out for correct output. The numbers are the problem indices in the judge system. "make number" to m

Pangfeng Liu 6 Jan 10, 2022
Muriqui Optimizer - A convex mixed integer nonlinear programming solver

Muriqui Optimizer Muriqui Optimizer is a solver for convex Mixed Integer Nonlinear Programming (MINLP) problems. For more informations and user manual

null 5 Oct 4, 2022
Parallel programming for everyone.

Tutorial | Examples | Forum Documentation | 简体中文文档 | Contributor Guidelines Overview Taichi (太极) is a parallel programming language for high-performan

Taichi Developers 22k Jan 4, 2023
competitive programming prep Gadz'IT

CP-training The users Folder contains every user's submission The personnal folder structure must be as follows : Available platforms Arena Moi (arena

GadzIT 4 Jan 1, 2022
Weekly competitive programming training for newbies (Codeforces problem set)

Codeforces Basic Problem Set Weekly competitive programming training for newbies based on the Codeforces problem set. Note that, this training problem

Nguyen Hoang Hai 4 Apr 22, 2022