Skip to content
Cheeky prototypes for Common Lisp
Common Lisp Other
Find file
Fetching latest commit…
Cannot retrieve the latest commit at this time.
Failed to load latest commit information.



Sheeple is a Dynamic, CLOS-like, Delegative Prototype-based Object-Oriented Programming Framework (or "POOP Framework") that strives to optimize application flexibility, minimize cost while increasing value, maximize programmer resources, and empower application implementers to better assist them in leveraging modern paradigms in order to proactively achieve next-generation synergy in tomorrow's web 3.0 world. It is implemented in (mostly) ANSI Common Lisp. Sheeple is fully buzzword compliant.

Sheeple was originally written as a persistent library for use with Sykosomatic. When that didn't work out, it was simply rewritten as a regular prototype object system and provided as a standalone library meant for general-purpose OO hackery. I was mostly motivated to split it off because I kept running into different problems in other apps where I wished I could express things the way Sheeple does things.

Sheeple is inspired by a number of Object-Oriented systems, mainly:

  • CLOS, the Common Lisp Object System.
  • LPC, a common language for building MUDs
  • MOO, implemented and used by LambdaMOO
  • Slate, a Smalltalk-like language with Prototype Multiple Dispatch that Sheeple bases its message dispatch system on.
  • Self, another Smalltalk-like language with lots of papers written about it, and the concept of prototype OO.

It was written with the purpose of providing a lot of the goodies of CLOS programming in a completely prototype-based environment. As such, it shares a lot of features and syntax with CLOS. The most notable features are multiple inheritance and multimethods, called multimessages).

Supported Platforms

Confirmed to work (pass all tests):

  • SBCL
  • Clozure CL
  • LispWorks

Sheeple doesn't use any OS-specific code (or threads), so it should be fairly stable on all operating systems. OSX and Linux x86 have both been actually tested on the aforementioned platforms.

Loading Sheeple

It's fairly effortless to get Sheeple working. To get started, simply

     (asdf:oos 'asdf:load-op 'sheeple)
     (in-package sheeple-user)

And mess around from there. Be aware that if your implementation does not include ASDF, you will have to acquire it and load it yourself. Clisp, for example, will require this. For information on how to do this, check out Cliki, or the ASDF Homepage.

Sheeple should work on most Lisp implementations, although it's mainly written and tested in SBCL on Linux x86.

FiveAM is required if you wish to run the test suite. To run it:

    (asdf:oos 'asdf:load-op 'sheeple-tests)


If you want to get Sheeple to run on your favorite platform, feel free to e-mail me: zkat, in the domain of sykosomatic, tld org. I'll help as much as I can (or even do the work for you). Any and all comments are also greatly appreciated.


Because of a combination of the necessity to avoid name collisions in a system very similar to CLOS and a desire to amuse myself (and others), Sheeple has been designed from the beginning to be maximally groan-worthy with its naming scheme. I apologize in advance, and I am not responsible for any issues the naming scheme might cause, such as Chronic Smug Weenie Nose-Tilting Syndrome.

I assure you, Sheeple is Serious Business(tm) for Serious Applications(tm).


  • DEFCLASS*-like DEFSHEEP and CLONE macros.

  • Dynamic object management tools (inspection of objects, addition/removal of properties, all without requiring full redefinition/object updating).

  • Delegative property value access.

  • Full integration with built-in Lisp types (wolves) through autoboxing (called fleecing).

  • Multiple inheritance through cloning with dynamic inspection and management (adding/removing) of parents.

  • Multiple dispatch on messages (methods) -- messages specialize on specific instances, and follow inheritance hierarchy. Multimessage definition is almost identical to the core of CLOS methods, and shares similar semantics.

  • Dynamic removal of messages, as well as entire buzzwords with undefbuzzword/undefmessage.

  • Auto-generated readers/writers, with :accessor, :reader, and :writer property options.

  • :before, :after, and :around messages

  • (call-next-message) and (next-message-p)

Planned features:

  • A metaobject protocol

Using Sheeple

Please refer to #P"doc;" for a quick-and-dirty intro to Sheeple and how to use it.

You can also take a peek at the demo/ directory for examples.

As usual, you can always contact me directly with questions. I also regularly lurk in #lisp@freenode (as zkat).

Something went wrong with that request. Please try again.