Download Now

Download the FREE Open Source version


Licensing information:

The db4o engine is free when licensed under the General Public License (GPL).

A commercial license is required if you want to embed db4o in a commercial product and/or receive professional support.


Download Product Information:

In English (PDF)
In Japanese (PDF)
In Chinese (PDF)
In German (PDF)
In Portuguese (PDF)

db4o :: Java & .NET Object Database :: db4o Database Engine:: Open Source Object–Oriented Database :: Product Information

db4o is the open source object-oriented database that enables Java and .NET developers to store and retrieve any application object with only one line of code, eliminating the need to predefine or maintain a separate, rigid data model.

World class innovators deploy the db4o database engine at the heart of next generation data-driven devices and applications to cache user-generated and client-side data, enabling compelling new features and achieving unprecedented performance and flexibility.

The One-Line-of-Code Database Eliminates Complexity

The secret of db4o's success is its ease of use because it is native to Java and .NET, storing data objects exactly in the way they are defined by the application. db4o therefore easily integrates into the application and performs highly reliable and scalable persistence tasks with just one single line of code, no matter how complex object structures may be. You are no longer required to predefine or maintain a separate, rigid data model, because the model is now created and updated 'on demand' by db4o itself during a transaction.

It's as easy as this: Drop db4o's single programming library (.jar /.dll), which you can download here, into your development environment, create a blank database file and store any object - no matter how complex - with just one line of code, e.g., in Java:

  public void store(Engine engine){
    ObjectContainer db =
       Db4o.openFile("car.yap");
    db.set(engine);
    db.commit();
    db.close();
  }

Done! db4o has created the data model during the transaction and stored the 'engine' object.

This unmatched ease-of-use results in drastically reduced development time and allows for efficient deployment in large volumes. It eliminates the entire work and the constraints of (pre-)designing, implementing and maintaining the database schema, because the class model is the database schema. Even when deploying software updates, db4o's automatic schema versioning takes care that the software and the database are always in sync, while you can focus on building value-add product features!

Less Time to Bother with Persistence -- More Time to do Build Exciting Products!

The less time developers spend on cumbersome persistence code, the more they can focus on building truly differentiated products, which leverage persistence capabilities on the client-side for previously unthinkable 'smart' architectures:

  • Store and retrieve data on devices, within your client-side software or anywhere in the network, with the robustness, scalability and reliability of a device-grade, ACID-safe database engine
  • Build truly object-oriented applications with powerful, native retrieval options rather than chopping strings for database access
  • Build blazing fast persistence into Java or .NET applications, optimized for low memory consumption
  • Change, refactor and customize software more easily because there is no need to manually keep the database schema in sync with the application schema
  • Use more complex object models and object navigational graphs to build more feature rich products
  • Combine the benefits of a mature product with the flexibility of roll-your-own software by using db4o's open sources

Relational Databases, Roll-Your-Own and db4o's Object Database

All object-oriented software developers are familiar with the difficulty transitioning from object-oriented thinking to relational persistence. Often, they have been forced to choose between speed and object-orientation: Native SQL access is fast, but laborious, requiring a great deal of additional code. Object-relational mappers offer a convenient bridge, but they seriously degrade performance by up to 55x, as benchmarks have shown. Many developers end up writing their own client-side persistence based on serialization, flat files or XML, losing the benefits of an ACID transaction-safe database engine and cannot easily query, replicate, or instrument schema changes without breaking the data file.

db4o puts an end to these trade-offs:

  • Unlike relational databases, db4o eliminates the object-relational mismatch entirely
  • Unlike roll-your-own persistence or serialization, db4o is ACID transaction safe and allows for querying, replication and schema changes during runtime
  • Unlike object-relational mappers, db4o allows for up to 55 times faster performance and smaller footprint
  • Unlike non-native Java or .NET database engines, db4o can run in the same memory process to enhance reliability, to provide for powerful memory and performance tuning, and to allow frequent refactorings with your IDE
  • Unlike other open source products, db4o has the most active and largest community of its kind
  • Unlike closed source products, db4o's open sources gives you the ability to modify, optimize and integrate the engine easily according to your specific needs

Powerful Retrieval APIs and UIs

Unlike string-based SQL, JDOQL and other interfaces, which are alien to OO progamming languages Java and .NET (and consequently cannot be refactored automatically, for instance), db4o offers truly native and object-oriented data access APIs which are setting new standards in the computing industry:

  • Native Queries allow to use the native program language, Java or .NET, to query the database
  • Query by Example (QbE) makes it easy to search for matching objects
  • Navigation by object graph allows to activate objects on demand with transparent activation
  • Ad-hoc queries for debugging and during runtime with the ObjectManager
  • Ad-hoc reporting with standard third party tools

Here is an example of a Native Query in C# for .NET 2.0:

  IList<Student> students = db.Query<Student>(delegate(Student student){
    return student.Age < 20
      && student.Grade == gradeA;
  });

As you can see, Native Queries eliminate all strings from queries - they are 100% type-safe, 100% refactorable, and 100% object-oriented. They improve developer productivity and allow for easier product customization (e.g., using inheritance).

db4o - The World's Most Popular Object Database

The db4o open source project has brought a developer dream to the masses, driven by the largest community of its kind. With millions of downloads, tens of thousands of registered developers, and hundreds of prestigious customers, from world class leaders like Boeing, Bosch, Intel, Ricoh, and Seagate, to a wide range of highly innovative start-up companies, have embedded object database technology to solidify a firm place in the toolbox of every innovative Java or .NET software developer.

New users will find that they can easily download and get started with db4o in just 5 minutes or less. A comprehensive interactive tutorial comes with the download, helping developers to get started and easily transition from relational to object-oriented thinking.

Further Information

Complimentary Products