About Epoch

Every seasoned programmer knows that building great software involves making some compromises. Choosing a programming language doesn't need to be one of them!

Epoch is a language designed to be opinionated. It has been built from the ground up to emphasize certain mindsets and approaches to building software systems and applications, at all scales. Make no mistake, Epoch is probably not for everyone - but if you're a like-minded developer, working from a similar frame of reference, we hope it scratches your itch as well as it scratches our own.

Where It Stands

  • Procedural, structured foundation with generic programming support
  • Strong, statically-checked type system
    • Built-in integral, floating point, Boolean, and string types
    • Product types (structures)
    • Algebraic sum types
    • Type aliases with control over conversion rules
    • Zero implicit type conversions
    • No nullable types; use a sum type with nothing as a member
    • Value-semantics by default, can opt-in to reference semantics per variable
    • Static function dispatch by argument type (overloads)
    • Dynamic function dispatch by type or value (pattern matching)
  • Just-in-time compilation to native machine code
    • Ahead-of-time compilation generates a custom bytecode format
    • JIT engine turns this into LLVM intrinsic bitcode at load time
    • Exploits the full LLVM optimization suite on all Epoch code
    • Carefully written Epoch can hold its own in synthetic benchmarks
  • Automatic garbage collection for memory management
  • Prototype editor with integrated syntax highlighting

Where We're Going

  • "Task" model of programming
    • Tasks are basically first-class closures with message passing support
    • Messages use existing pattern-matching support in the language
    • Polymorphism via protocols which describe what messages a task will answer
    • Retains static type guarantees from the rest of Epoch
  • Fine-grained resource control
    • Optional garbage collection for both memory and other resources
    • Deterministic resource management for when GC is suboptimal
    • Custom allocation controls for memory layout
    • Rich interface for hooking the garbage collector from Epoch code
  • Execution model enhancements
    • Integrated support for native OS threading APIs
    • Support for custom-dispatched "green" threads
    • First class coroutines
    • Built-in abstractions for easy inter-process communication
    • Support for Remote Procedure Call implementations
  • Compiler and tool-chain updates
    • Native 64-bit support (32-bit support will be deprecated)
    • Removal of JIT layer and transition to pure Ahead-of-Time compilation
    • Continued adoption of cutting-edge LLVM features
    • Ongoing refactoring of compiler/tools for cleanliness and extensibility
    • Expansion of IDE and debugging tools
  • Broader platform support (Linux, BSD, OS X)