Cone Programming Language

Cone is a fast, fit, friendly, and safe systems programming language. It features:

Do-it-your-way memory management
Versatile type system (incl. variant types and slices)
Memory, thread & type safe
Extensive code reuse features
Lean, native runtime
Concise, readable syntax

The Cone compiler is currently under development. The current status and next steps are documented in PLAN.md.

Documentation and Other Resources

Cone web site
Web-based playground, offering pre-built examples in a drop-down
Cone Language Reference documentation
Programming Linguistics blog

The Cone home repository offers a rudimentary build environment for Cone programs, including the Congo build tool and additional example Cone programs.

Language Features

When finished, Cone will support these features:

Readable, modular marriage of 3D content and behavior:
- Simple, outline-like declarative syntax for content
- Procedural generation and behavior interwoven in content
- Snap-together, Internet-hosted, url-located parts
Compile-time memory, type, and concurrency safety checks
Gradual memory management: safely manage memory your way
- Lexical, single-owner strategy for performance
- Ref-counted or tracing GC for flexibility
- Lifetime-constrained references for performance/simplicity
- Custom allocators (pools/arenas) for performance
Lightweight concurrency
- Co-routines, threads and actors
- Lockless and locked permissions for safe data sharing
Robust type system
- Sum types, structs, arrays, slices, ranges, aliases
- struct subtyping via trait, interface, & parent inheritance
- Attach methods to any type
Modules, macros, templates and meta-programming
Extensible pattern matching
- Type-defined '~~' match operator
- 'match' blocks using custom match methods
- Content extraction during matching
Functions, Methods and Closures
- Multiple return values and implicit return
- Computed properties
'do' block for context management
Concise, readable code:
- 'this'-implied prefix operators for method cascading, etc.
- Operator overloading
- Control clauses for 'if', 'while', 'each'
- Type inference
- Parallel assignment
- Auto-detected off-side rule
- Blocks and 'if' are expressions
Unicode-aware (UTF8) text strings and variable names
Fast compilation and convenient packaging

Building (Windows)

A Visual Studio C++ solution can be created using the Cone.vcxproj project file. The generated object and executable files are created relative to the location of the solutions file. The build depends on LLVM 7 being installed and available at $(LLVMDIR).

Building (Linux)

To build on Linux:

sudo apt-get install llvm-7.0-dev
cmake .
make

Note: To generate WebAssembly, it is necessary to custom-build LLVM, e.g.:

mkdir llvm
cd llvm
svn co http://llvm.org/svn/llvm-project/llvm/trunk llvm-src
cd llvm-src/tools
svn co http://llvm.org/svn/llvm-project/cfe/trunk clang
svn co http://llvm.org/svn/llvm-project/lld/trunk lld
cd ../..
mkdir llvm-build
cd llvm-build
CC=clang CXX=clang++ cmake -G "Unix Makefiles" -DLLVM_BUILD_LLVM_DYLIB=ON -DCMAKE_INSTALL_PREFIX=/llvm/wasm -DLLVM_EXPERIMENTAL_TARGETS_TO_BUILD=WebAssembly /llvm/llvm-src
make
make install

Building (Mac OS)

To build on Mac OS:

brew install --with-toolchain llvm
llvm-config --bindir

CMake will auto-detect LLVM, so all you should need to do:

cmake .
make

License

The Cone programming language compiler is distributed under the terms of the MIT license. See LICENSE and COPYRIGHT for details.

sudison/cone