Mewlang

Mewlang is a hands-on programming-language learning project built around one idea:

Don't just learn a language. Discover what it makes possible.

The Mewlang cat looking up, curious Instead of following syntax tutorials or building the same CRUD application in every language, Mewlang explores programming languages through projects designed around their unique strengths, philosophies, and programming models.

🧠 The idea

Every programming language has something interesting about it.

Go makes concurrent systems approachable.
Ruby makes metaprogramming and expressive DSLs feel natural.
Perl turns text processing into a superpower.
Erlang treats massive concurrency and failure as fundamental design problems.
Racket makes creating programming languages surprisingly accessible.

Mewlang uses projects to make those differences tangible.

🐾 Projects

🐜 Go — Digital Ant Colony

Build a large concurrent simulation where thousands of autonomous ants search for food, communicate, leave pheromone trails, and recover from failures.

Explore: Goroutines, channels, concurrency, synchronization, context cancellation, worker pools, race detection, fault injection, and distributed systems.

What happens when concurrency becomes the natural way to model the world?

Start the Go course →

🐱 Ruby — Programmable Automation DSL

Build a Ruby-based automation framework where pipelines can be written almost like a programming language:

pipeline "research" do
	fetch "papers"
	filter topic: "AI"
	summarize
	save_to "knowledge_base"
end

Explore: Blocks, Procs, lambdas, objects, reflection, method_missing, dynamic methods, metaprogramming, DSL design, and runtime introspection.

What if your application could become its own language?

Start the Ruby course →

🕵️ Perl — Text Archaeologist

Build a data-forensics tool capable of digging through messy real-world text and extracting useful structure.

Process: Logs, CSV, JSON, XML, source code, configuration files, malformed data, and arbitrary text.

Explore: Regular expressions, text transformation, file processing, streams, references, Unix pipelines, CLI applications, CPAN, parsing, and data processing.

What happens when text manipulation is the core of the language?

Start the Perl course →

🐉 Erlang — The Internet That Never Dies

Build a simulated distributed network containing thousands of nodes that communicate, crash, restart, disconnect, and recover automatically.

Explore: Processes, message passing, pattern matching, receive, links, monitors, OTP, gen_server, supervision trees, distributed systems, and fault tolerance.

Eventually, deliberately destroy parts of the network and watch it recover.

What if failure wasn't an exception, but a normal operating condition?

Start the Erlang course →

🧪 Racket — Language Factory

Build a toolkit for creating small domain-specific programming languages for finance, robots, configuration, and games.

Explore: Functional programming, higher-order functions, structs, macros, syntax objects, hygienic macros, parsers, ASTs, interpreters, compilers, #lang, and language-oriented programming.

What if learning a programming language meant learning how to create one?

Start the Racket course →

🎯 Philosophy

Learn by building — Every language is learned through a substantial project.
Exploit the language — Use features that make the language distinctive.
Understand the “why” — The goal is to understand why someone would choose this language.
Compare programming models — The same problem can look completely different depending on the language.
Build real software — Include tests, error handling, documentation, CLI interfaces, logging, configuration, performance considerations, and debugging.

🗺️ Learning Path

                    🐱 MEWLANG
												│
				┌───────────────┼───────────────┐
				│               │               │
		Concurrency     Expressiveness    Data
				│               │               │
			 Go              Ruby            Perl
				│
				├───────────────┐
				│               │
	 Fault Tolerance   Language Design
				│               │
			Erlang          Racket

Each project explores a different way of thinking about software.

🛠️ What you'll learn

Imperative, functional, and object-oriented programming; metaprogramming; domain-specific languages; concurrency; actor systems; distributed systems; fault tolerance; parsing; compilers; interpreters; type systems; Unix philosophy; testing; debugging; and performance engineering.

More importantly, you'll learn how programming language design influences software architecture.

🚀 Getting started

Choose a language and start with its project. You don't need to know the language beforehand.

Language basics
			↓
Tiny exercises
			↓
Small prototype
			↓
Project milestone
			↓
More language features
			↓
Advanced architecture
			↓
Final challenge

The Mewlang cat's paw, raised for a high five The objective isn't to memorize syntax, but to reach the point where you can think: “This language would be interesting for this.”

Read the full curriculum →

🧩 Why “Mewlang”?

The Mewlang cat, winking Because programming languages are weird creatures. Some are good at concurrency, some manipulate text beautifully, some reshape the language itself, some survive failure, and some make types do incredible things.

Different languages. Different powers. Different ways of thinking.

📌 Project Status

Mewlang is an educational project and an ongoing exploration of programming languages. New languages and projects can be added over time.

Potential future explorations: OCaml, Haskell, Clojure, Zig, Smalltalk, Crystal, Nim, and F#.

⭐ The goal

Mewlang isn't about finding the best programming language. It's about discovering that there isn't one universal way to think about software.

Learn the language.
Build something weird.
Break it.
Understand why it works.
Then learn another language and see the problem differently.