fun> :load /index.fun

Announcing Fun 0.40.5

Apr 17, 2026 00:00:00 (CEST) - Edited: Apr 18, 2026 00:17:13 (CEST), hanez

We are thrilled to announce the release of Fun version 0.40.5! This update represents a major leap forward in language capabilities, developer experience, and project infrastructure since our last major announcement (v0.37.62).

Key Highlights of Version 0.40.5

Nested Functions & Higher-Order Patterns

The most significant language enhancement is the addition of nested functions in the Fun parser. This allows for cleaner encapsulation and enables powerful functional programming patterns, such as closures and advanced higher-order function implementations.

fun outer(x)
  fun inner(y)
    return x + y
  return inner

f = outer(10)
print(f(5))  // 15

Rust & C++ Integration

Fun is getting more “multi-lingual.” We’ve introduced support for implementing opcodes in Rust, allowing developers to leverage Rust’s safety and performance within the Fun VM. Additionally, we’ve started evaluating C++ integration for those who need it.

Improved Tooling: funstx

We’ve introduced funstx, a dedicated linter for Fun. It helps maintain the “Indentation is Truth” philosophy by ensuring your code follows the strict 2-space indentation rule and other stylistic consistency checks.

CI Automation & Reliability

To ensure the stability of the language as it grows, we’ve implemented a full GitHub Actions CI workflow. Every commit now triggers automated execution of our extensive examples library, catching regressions early.

VM Configuration & Performance

The Fun VM is now more flexible than ever. Key parameters like MAX_FRAMES, STACK_SIZE, and OUTPUT_SIZE can now be configured at build time via CMake defines (-D), allowing you to tune the VM for specific environments (from embedded systems to beefy servers).

Changelog (v0.37.62 to v0.40.5)

Added

• Nested Functions: Full support in the parser (v0.40.0).
• Rust Integration: Build and link Rust-based opcode libraries (v0.38.0).
• GitHub Actions: CI Automated testing and example validation (v0.39.15).
• Linter (funstx): New tool to enforce code style and indentation (v0.39.0).
• Configurable VM: Build-time tuning of memory limits via CMake (v0.40.5).
• Specification v0.4: Updated language specification.
• New Stdlib Modules: AES256 support, improved asyncio/scheduler, and more.

Changed

• Documentation Relocation: All documentation moved to ./web/documentation/ for better website integration.
• Website Overhaul: The website code was moved to ./web/ for easier maintenance.
• Example Refactoring: Reorganized the ./examples directory for better clarity and CI integration.
• Code Style: Standardized all C files to two-space indentation.

Removed (Cleanup & Focus)

• Removed support for libsql, tcltk, notcurses, and libressl to streamline the core and focus on more modern alternatives (v0.40.2 - v0.40.5).

Fixed

• Improved line number reporting in error messages (v0.39.15).
• Various bug fixes in the VM and standard library modules.

The Road to 1.0

As always, Fun remains an experiment, but with version 0.40.5, we are closer than ever to a stable 1.0. We’ve focused on cleaning up experimental features that didn’t fit our minimalism philosophy while adding the powerful primitives needed for real-world hacking.

Want to try it out? Head over to our Git Repository or check out the updated Documentation.

Happy hacking, and remember: Fun is Fun!

Johannes Findeisen (hanez) - hanez@fun-lang.xyz

[Read post]

Moving the Website to the Project Root

Apr 10, 2026 00:00:00 (CEST) , hanez

We’ve recently completed a significant change to our project structure: the source code for the fun-lang.xyz website has been moved directly into the root of the main Fun project repository.

Why the Move?

The main reason for merging this code into the root of the Fun project is that it is much easier for me to maintain the whole project this way.

Having everything in one place simplifies our development workflow:

• Unified Versioning: All project components, including the website and its documentation, now share the same version control history.
• Simplified Maintenance: Updating documentation and the website together ensures that the online presence stays in sync with the language’s development.
• Streamlined Workflow: It’s now possible to update the language, its libraries, the documentation, and the blog in a single commit if needed.

Where is it located?

You can now find the website source in the ./web/ directory of the repository. It continues to use the Jekyll static site generator.

For those interested in the technical details or looking to contribute to the website, we have added a new documentation file: /web/documentation/website/. This document covers the technology stack, the directory structure, and the available Makefile targets for local development and deployment.

What changes for you?

For most users, nothing changes! The website remains available at https://fun-lang.xyz. If you are a contributor or following the project closely, you’ll just need to look into the ./web/ directory instead of a separate repository.

Happy hacking!

Johannes Findeisen (hanez) - hanez@fun-lang.xyz

[Read post]

Announcing Fun 0.37.62

Jan 25, 2026 00:00:00 (CET) - Edited: Apr 11, 2026 00:56:03 (CEST), hanez

First at all! Special thanks go to my wonderful girlfriend Sabine, my friends Armin and Ole, who motivated me over the past month to implement this. Cheers! Markus, I miss YOU, R.I.P!

We’re excited to announce the release of Fun version 0.37.62, the latest iteration of our experimental programming language that prioritizes simplicity, consistency, and most importantly — joy in coding.

Link to Hackernews post.

What’s Fun All About?

Fun is a highly strict yet highly simple programming language that draws inspiration from Bash, C, Lua, PHP, Python, and Rust. If you love Python’s clean syntax but want something with stricter rules and built-in type safety, Fun might be worth exploring. It’s dynamically typed with optional static typing, written in C (C99) and Fun itself, and designed to be small, embeddable, and hackable. More on the about page.

Important: This is an Experiment

Please note: Fun is an experimental language and should be treated as such. While Fun works, it has many known and unknown bugs. We will not declare Fun as stable until we reach the 1.0 release. This is a project born out of curiosity and passion for elegant code, not production readiness — at least not yet.

What Makes Fun… Fun?

Philosophy

Fun is built on the idea that coding should be enjoyable, elegant, and consistent. Our manifesto includes core principles like:

• Fun is Fun – Programming should spark creativity, not frustration
• Fun Uses Nothing – Minimalism is power; no unnecessary features or syntax variations
• Indentation is Truth – Two spaces, always (no tabs, no debates, no four-space wars)
• One Way to Do It – No clutter, no 15 ways of writing the same thing. Simplicity means clarity
• Hackable by Nature – Small and embeddable, like Lua. Easy to understand, extend, and tinker with
• Beautiful Defaults – A language that doesn’t need linters, formatters, or style guides. Beauty is built in

What’s New in Specification v0.3 (and Fun 0.37.62)

This release brings Fun closer to its vision with significant language enhancements:

• Object-Oriented Programming Classes and objects with methods, constructors, and inheritance using extends
• Explicit this in method definitions for clarity
• Private members by convention (leading underscore)
• Dot-call syntax sugar for clean method invocations: obj.method(a, b)

class Counter
  value = 0
  fun inc(this)
    this.value = this.value + 1
    return this.value

c = Counter()
print(c.inc())  // 1

Module System

• Namespaced includes with #include as alias for clean imports
• Organize code into reusable modules without naming conflicts

#include <utils/math.fun> as m
print(m.add(2, 3))  // 5

Enhanced Type System

• Fixed-width integers: int8, uint8, int16, uint16, int32, uint32, int64, uint64
• Maps/dictionaries: map<K, V> with literal syntax { “key”: value }
• Typed arrays: array for type-safe collections
• Byte type for low-level operations

Concurrency Support

• Thread primitives: thread_spawn, thread_join, and sleep
• Write concurrent programs with ease

fun square(n)
  sleep(100)
  return n * n

tid = thread_spawn(square, 5)
print(thread_join(tid))  // 25

Control Flow Improvements

• Loop control: break and continue statements
• Exception handling: try/catch/finally syntax (runtime implementation evolving)

System and Network Integration

• Process execution: Blocking (exec, system) and non-blocking (nexec, nspawn) with process management
• TCP and Unix domain sockets: Build networked applications
• Serial port support: Communicate with hardware devices
• Environment variables: Access with env(NAME)
• CLI argument handling: Parse command-line arguments

Additional Features

• Bitwise operations: band, bor, bxor, bnot, shl
• Rich standard library with modules for cryptography (MD5, SHA1/256/384/512, CRC32), encoding (Base64, hex), JSON, XML, INI, regular expressions (PCRE2), datetime utilities, and more
• Optional extensions for cURL, SQLite/libSQL, PC/SC smart cards, and Tk GUI toolkit

Core Language Features

Fun provides a clean, readable syntax with:

• Strict indentation-based structure (2 spaces, no semicolons)
• Type safety with no implicit numeric coercions
• Bounds-checked operations to prevent common errors
• Higher-order functions: map, filter, reduce for functional programming
• Multiple return values from functions
• Comprehensive built-ins for common tasks

The Community: Fun Unites Nerds

Fun isn’t about being the fastest or most feature-rich language — it’s about sharing the joy of coding. We welcome contributors who are:

• Respectful
• Curious
• Creative

A language that feels like home for developers who love minimal, elegant tools, believe consistency is freedom, and want to write code that looks good and feels good.

Want to Participate?

Everybody is welcome to participate! However, before you can get started, you need to contact me at hanez@fun-lang.org to request an account on our Git server.

Important: Fun is not developed on third-party Git servers like GitHub or GitLab. All Fun infrastructure is self-hosted at git.xw3.org. This keeps us independent and aligned with the hacker spirit of the project — we control our tools, our code, and our community.

Getting Started

If you’re curious about Fun, check out:

• Git Repository
• Fun Handbook
• Fun REPL Guide
• Specification v0.3
• Examples
• Standard Library
• Community

The examples directory contains demonstrations of most Fun features, from basic “Hello, World!” to threading, networking, classes, and more. The lib directory includes modules written in Fun itself — and in the future, most enhancements will be written in Fun rather than C.

For Developers

• Fun Internals
• Fun Opcodes
• Basic Rust Opcodes Support

The Road Ahead

Documentation is a work in progress as we continue debugging, fixing bugs, and evolving the language. Complete API documentation will follow in future releases. Version 0.37.62 represents substantial progress, but remember: this is an experiment, and stability won’t be declared until we reach 1.0.

Fun may not change the world, but it aims to make programming a little more fun. We’re on a journey, and we’d love to have you along for the ride — bugs and all.

Fun is and will always be 100% free under the terms of the Apache-2.0 License.

Happy hacking, and remember: Fun is Fun!

Johannes Findeisen (hanez) - hanez@fun-lang.xyz

[Read post]

Init Fun!

Oct 5, 2025 00:00:00 (CEST) , hanez

Initial homepage… no content actually!

[Read post]