Yali (Yep, Another Lisp Interpreter) is extremely small Lisp interpreter. Designed, first of all, for calculating factorials.

Usage:
make
./repl

And you're in REPL. Now you can define your own factorial function. Just like this:
>>> (define (fact x) (if (= x 0) 1 (* x (fact (- x 1)))))
Done. Now you can calculate factorials:
>>> (fact 15)
Eval = 1307674368000
Another example:
>>> (define (fibo x) (if (= x 1) 1 (if (= x 2) 1 (+ (fibo (- x 1)) (fibo (- x 2))))))

TODO:

• Split current shitty parser to good lexer and recursive parser. ✔
• Add lambdas as first-class objects. ✔
• TCO.
• Add string data type. ✔
• Add floating-point number data type. ✔
• Add minimalistic standard library of built-in functions. ✔

• List operations (car, cdr, cons, map, reduce). ✔
• Type conversions and predicates. ✔
• Basic arithmetic, logic and comparison operations. ✔
• I/O functions.
• Time measurement functions.
• Execution flow control function.

• Create own data types, instead of using C types.
• Liquidate memory leaks in evaluator's core. Preferrably, by building GC.
• Add scopes, preferably lexical.

• Add blocks as first-class objects. Block is a sequence of SExpressions, evaluated from top to bottom (last expression evaluation result is returned). Block has its own lexical scope. So, define will define not lambda-object, but block-object.

• Error reports.
• Static typing. (I'm not kidding.) (Actually, i don't think it's possible. But i definitely can make a new form of define, define-typed, which will define a function with incapsulated type checking. And every time this function will be called, it will typecheck its arguments by itself. Example of syntax: (define-typed (factorial x) (:: (int? x)) (...))).
• Add mode to interpret whole source files, not only repl-mode.