Erlang Online Compiler

Compile and run Erlang programs with our concurrent runtime environment. Perfect for distributed systems, fault-tolerant applications, and learning the actor model.

erlang Online Compiler

-module(main).
-export([start/0]).

start() ->
    io:format("Hello, World!~n"),
    io:format("Welcome to Erlang Online Compiler~n"),
    
    % Variables (actually constants in Erlang)
    Language = "Erlang",
    Version = 26.0,
    IsConcurrent = true,
    
    io:format("Language: ~s~n", [Language]),
    io:format("Version: ~w~n", [Version]),
    io:format("Concurrent: ~w~n", [IsConcurrent]),
    
    % Lists
    Numbers = [1, 2, 3, 4, 5],
    io:format("Numbers: ~w~n", [Numbers]),
    
    % List comprehensions
    Squares = [X*X || X <- Numbers],
    io:format("Squares: ~w~n", [Squares]),
    
    % Pattern matching
    {Name, Age} = {"Developer", 29},
    io:format("Person: ~s, Age: ~w~n", [Name, Age]),
    
    % Function calls
    Factorial5 = factorial(5),
    io:format("Factorial of 5: ~w~n", [Factorial5]),
    
    % Atoms and tuples
    Status = ok,
    Result = {Status, "Operation completed successfully"},
    io:format("Result: ~w~n", [Result]),
    
    % Process creation (simplified)
    io:format("Creating processes...~n"),
    spawn_processes(3),
    
    % Guards and case expressions
    Number = 42,
    Description = describe_number(Number),
    io:format("~w is ~s~n", [Number, Description]),
    
    % Binary pattern matching
    Binary = <<"Hello, Erlang!">>,
    io:format("Binary: ~s~n", [Binary]),
    
    ok.

% Recursive function
factorial(0) -> 1;
factorial(N) when N > 0 -> N * factorial(N - 1).

% Function with guards
describe_number(N) when N < 0 -> "negative";
describe_number(0) -> "zero";
describe_number(N) when N > 0, N < 10 -> "small positive";
describe_number(N) when N >= 10 -> "large positive".

% Process spawning example
spawn_processes(0) -> ok;
spawn_processes(N) ->
    spawn(fun() -> 
        io:format("Process ~w: Hello from process!~n", [N])
    end),
    spawn_processes(N - 1).

Output

Click "Run" to execute your code and see the output here...

-module(main).
-export([start/0]).

% Recursive function
factorial(0) -> 1;
factorial(N) when N > 0 -> N * factorial(N - 1).

% Process spawning example
spawn_processes(0) -> ok;
spawn_processes(N) ->
    spawn(fun() -> 
        io:format("Process ~w: Hello from process!~n", [N])
    end),
    spawn_processes(N - 1).

Erlang Compiler Features

Erlang/OTP 26 runtime
Massive concurrency support
Pattern matching and guards
Actor model implementation
Fault tolerance and supervision

About Erlang Programming

Erlang is a programming language designed for building massively scalable, fault-tolerant systems. It was originally developed by Ericsson for telecommunications systems and follows the actor model.

Erlang excels at concurrent programming with lightweight processes, message passing, and built-in fault tolerance. It's used in systems that require high availability and can handle millions of concurrent connections.

Use our Erlang online compiler to learn concurrent programming concepts, explore the actor model, or build distributed systems without setting up a local Erlang environment.