Carbon is a light-weight component model and services framework providing enterprise quality services. Carbon is built on the following principles:

* Create a more flexible architecture via a decoupled, metadata-centric system
* Reduce complexity by providing access to services as small replaceable components
* Encourage the separation of concerns, resulting in code assets that are easier to maintain, adapt and reuse in a complex and dynamic operating environment
* Improve quality with highly documented, fully tested code

Gravity is a dependency and configuration management framework that allows multiple forms of configuration via a plugin model with a primary focus on the Dependency Injection / Inversion of Control (IoC) design pattern. The framework comes with a default BeanShell plugin for configuring the components.

Yan container stands for Yet Another Non-intrusive container for object dependency injection.
The core of Yan is a compact Java API with no dependency to any other lib.
Around the tiny core, are services such as component monitoring, life cycle management, xml configuration etc.

JICE is an XML-based tool for constructing and configuring Java applications.
JICE specifies an XML-vocabulary for configuring the object in a Java application and provides tools for processing the XML-data into Java instances.
JICE supports Inversion of Control (IoC) / Dependency Injection: it can provide constructor parameters for objects and set the properties of the objects.
However, JICE is more than just an IoC container - in addition to setter methods, it can call any method of an object during initialization. JICE is capable of constructing complex object graphs, it is not limited in initializing beans.
the XML format especially is very compact and nice.

Peapod is a lightweight container. Peapod lets you take a plain Java class, an interface and a small fragment of XML metadata and hand off responsibility to a host. The combination of an interface, and implementing class and the metadata is a component; the host is Peapod. The responsibilities the host can take over are many. Here are some that Peapod handles:

* hot-deploy and undeploy of JARs: just drop in a directory or remove a file to install or uninstall a component
* intelligent dependency management: components are active only when all their declared dependencies have been satisfied--remove a component and all its dependents gracefully shut down; re-add it and they wake up
* code versioning: declare you require version 1.0 and seamlessly receive a access to facilities provided by a 1.1 implementation--you can even have both versions running in the same container
* combining the above three you get hot upgrades: undeploy a component, thus putting the dependents to sleep, deploy a newer version and not have to restart at all, enabling very high uptimes with a single lightweight server
* external configuration by metadata
* declarative aspect-oriented programming: use metadata to select code to insert at runtime between method calls made to an interface or even to a single method--tracing, security, transactions, single-threading, and more; the container includes several useful aspects you can use out of the box

Soto is a lightweight, non intrusive service framework relying on a powerful configuration format based on Java's introspection capabilities.
The framework implements neat ideas such as conditional instantiation, resource resolving and layers. It comes with JMX and AOP functionality.

DNA is a lightweight Inversion of Control (IOC) framework. DNA components have associated metadata that declares what resources they need to be provided and what resources they are capable of providing to other components.