Features

If you want to learn Horse64 and you can already code, check this introduction for programmers.

Here's cool stuff Horse64 can do:

Concurrency

Use effortlessly concurrent networking and disk I/O:

import net.fetch from core.horse64.org

func download_my_page {  # This won't block your entire program!
    var main_page = net.fetch.get_str("https://horse64.org")
    later:

    await main_page
    print("Downloaded web page: " + main_page)
}

This helps with designing programs that are scalable and can handle many remote resources at once without freezing.

Batteries included

The standard library offers many features, like an .ini config parser or a JSON parser:

import confparse from core.horse64.org

func check_config {
    # Read an ini file:
    var contents = confparse.parse_from_file("myconf.ini")
    print(contents["mysection"]["myvalue"])

    # ...or read it from the web?
    var remote_contents = confparse.parse_from_uri(
        "https://example.com/conf.ini"
    ) later:

    await remote_contents
    print("Got remote config!")
}

And thanks to its mostly independent runtime, it's easy to get it going.

When to use Horse64

(This is very subjective.)

🛡️ If you need an approachable but more stable language. Compared to Python, JavaScript, or Ruby, you'll find ahead-of-time checks in Horse64 while it retains a simple, type-free syntax.
☁ If you write backends and cloud tools. The built-in networking is concurrent, and the deployment is self-contained.
Not flawless: Horse64 isn't good at 🚫 extreme raw speed, 🚫 self-mutating scripting, and 🚫 detailed offline type checking (since it's dynamic).

For high performance, try Horse64 Root.

For the design goals, go here.

For an introduction for programmers of other languages, go here.

Comparison with other languages and use cases

⚠️⚠️⚠️ Horse64 is currently very unfinished. The following information is more of a roadmap, not the current state. ⚠️⚠️⚠️

Here's a comparison to Python, JavaScript (JS), Go, and C++. Disclaimer: this list is subjective, no guarantee of accuracy.

Please report inaccuracies..

Syntax, Core, and Code Flow Features

Horse64	Python	JS	Go	C++	Lua	Syntax, Core, and Code Flow
✔	✔	✔			✔	Dynamic types as a beginner-friendly default.
✔	✔		✔	✔	✔	Strongly typed to avoid silent harmful conversions.
✔	✔		✔		✔	Minimal, clean syntax without line terminators.
	✔	❓	✔	✔		Type annotations can be used for extra verbosity.
			✔	✔		Advanced type checker verifies types ahed of time.
✔	✔	✔			✔	Minimizes concurrency crashes in buggy code.
✔		✔	〰	✔	✔	Line breaks optional for versatile code layout.
✔		〰	✔			Concurrency of all I/O and network default APIs.
✔	✔	✔	✔	✔		Garbage-Collector to make avoiding leaks easier.
✔	✔	✔	✔		✔	Object-oriented class types as built-in feature.
✔		〰	✔		〰	Extend types without inheriting as built-in feature.
	✔			✔		Native multiple bases inheritance for mixins.
✔			✔			Auto-parallel threaded execution of every async call.
				❓	✔	Tail-call optimization enabled by default.
✔					✔	1-based indexing that is more beginner-friendly.

Multimedia and Desktop App Features

Horse64	Python	JS	Go	C++	Libraries and Desktop App Features
✔	✔	〰	✔	〰	Big standard library without extra setup.
✔		✔			UI and graphics integrated for easy graphical apps.
✔	✔	✔	✔		High-level networking by default for servers etc.
✔	✔	✔	✔	❓	Unicode with full grapheme support by default.

Deployment Features

Horse64	Python	JS	Go	C++	Lua	Deployment Features
✔			✔	✔		Portable program binaries as default output.
✔			✔	✔		Self-contained, no install needed for end users.
✔	✔		✔			Official packaging tools for easy project handling.
✔	✔	✔	❓		✔	Compiler trivially usable at runtime, if needed.
✔			❓	❓		Easily bake in all binary resources like images.
✔			❓			Virtual archive mounting for all standard I/O.
	❓	❓	✔	✔		Can make C API libraries easily for C/C++ program use.

Scripting Features

(⚠️ Horse64 is bad for this!)

Horse64	Python	JS	Go	Lua	Scripting Features
✔	✔	✔	❓	✔	Compiler trivially usable at runtime, if needed.
〰	✔	✔		✔	Instant script use for fast script helper launch.
	〰	✔		✔	Easy runtime `eval()` for trivial script injection.
		✔			Runs in web browser by default, for simple web use.
	✔	✔		✔	Embedded easily for integrated, subordinate scripts.
	✔	✔		✔	Easy runtime module loading for trivial mutability.
	✔	✔		✔	Dynamic global scope at runtime, extreme mutability.
	✔	✔	❓	✔	REPL shipped by default for dynamic experiments.

Large Project Features

Horse64	Python	JS	Go	C++	Lua	Tooling and Large Project Features
✔			✔	✔		Precompiled always, for better large project checks.
✔			✔	✔		Static name resolution to catch most typos early.
✔			✔	✔		Non-trivial optimizations and warnings by default.
			✔	✔		Forced type declarations for deepest compile checks.
✔	✔	✔			✔	Focused clean syntax to write larger projects fast.

Organizational Structure Comparison

Horse64	Python	JS	Go	C++	Lua	Organizational Structure Comparison
✔	✔	〰	✔		✔	One central default runtime for combined efforts.
✔	〰		✔	✔		Default compiler self-hosted, for easier changes.

Runtime Performance and Lowlevel Features

(⚠️ Horse64 isn't good at this, try Horse64 Root instead!)

Horse64	Python	JS	Go	C++	Lua	Runtime Perf. and Lowlevel Features
✔	✔	✔			✔	Bytecode interpreter for high portability.
✔			✔	✔		Attribute lookups largely AOT, to avoid bottlenecks.
✔		❓	✔	✔		Compiler made for AOT optimizations.
	〰		✔	✔		Largely lock-free memory sharing for fast threading.
		✔	✔	✔		Always uses JIT for speed, or 100% AOT compiled.
			✔	✔		Outputs machine code always, for extreme speed.
				✔		Fully manual allocations easily available.

(AOT refers to Ahead-of-Time, handled at compile time rather than runtime.)

For an advanced, faster low-level language, see Horse64 Root's list.

Technical specifications

There's also a more technical summary and specs here.

Okay, but how do I actually get started?

Go here for the initial setup.

Privacy | Admin Contact | Misc