atomic-server
An open source headless CMS / real-time database. Powerful table editor, full-text search, and SDKs for JS / React / Svelte.
Top Related Projects
Solid server on top of the file-system in NodeJS
Apache Jena, A free and open source Java framework for building Semantic Web and Linked Data applications.
Quick Overview
Atomic Server is an open-source, lightweight database and graph server with built-in authorization, versioning, and more. It aims to make data more interoperable and easier to work with by using Atomic Data, a modular specification for sharing, modifying and modeling typed data.
Pros
- Built-in versioning, authorization, and validation
- Supports multiple data formats (JSON, JSON-LD, RDF, Atomic Data)
- Easy to set up and use with a single binary
- Provides a user-friendly web interface for data management
Cons
- Relatively new project, which may lack extensive community support
- Limited ecosystem compared to more established database solutions
- Learning curve for developers unfamiliar with Atomic Data concepts
- May not be suitable for large-scale enterprise applications yet
Code Examples
Here are a few examples of using the Atomic Server API with Rust:
- Creating a new Resource:
use atomic_lib::Storelike;
use atomic_lib::agents::Agent;
let store = atomic_lib::Store::init().unwrap();
let agent = Agent::new_private();
let resource = store.create_resource(None, &agent).unwrap();
store.set_string(
&resource,
"https://atomicdata.dev/properties/shortname",
"my-resource",
&agent,
).unwrap();
- Querying Resources:
use atomic_lib::Storelike;
let store = atomic_lib::Store::init().unwrap();
let results = store.query(
Some("https://atomicdata.dev/classes/Agent"),
None,
None,
None,
).unwrap();
for resource in results {
println!("Found agent: {}", resource.get_subject());
}
- Updating a Resource:
use atomic_lib::Storelike;
use atomic_lib::agents::Agent;
let store = atomic_lib::Store::init().unwrap();
let agent = Agent::new_private();
store.set_string(
"https://example.com/resource",
"https://atomicdata.dev/properties/description",
"Updated description",
&agent,
).unwrap();
Getting Started
To get started with Atomic Server, follow these steps:
-
Install Atomic Server:
cargo install atomic-server
-
Run the server:
atomic-server
-
Open your browser and navigate to
http://localhost:9883
to access the web interface. -
Use the API endpoints or the Rust client library to interact with the server programmatically.
Competitor Comparisons
Solid server on top of the file-system in NodeJS
Pros of node-solid-server
- More mature project with a larger community and ecosystem
- Better documentation and resources for developers
- Implements the full Solid specification, providing a complete decentralized web solution
Cons of node-solid-server
- Heavier and more complex implementation
- Slower development cycle and potentially more challenging to contribute to
- May have higher resource requirements for deployment
Code Comparison
node-solid-server:
const solid = require('solid-server')
const path = require('path')
solid
.createServer({
root: path.join(__dirname, '../data'),
port: 8443
})
.listen(8443, () => {
console.log('Solid server running on https://localhost:8443')
})
atomic-server:
use atomic_server::Server;
#[tokio::main]
async fn main() -> std::io::Result<()> {
let server = Server::init().await?;
server.run().await
}
The node-solid-server example shows a more configuration-heavy setup, while atomic-server demonstrates a more concise initialization process. node-solid-server offers more out-of-the-box customization, whereas atomic-server prioritizes simplicity and ease of use.
Apache Jena, A free and open source Java framework for building Semantic Web and Linked Data applications.
Pros of Jena
- Mature and well-established project with extensive documentation and community support
- Comprehensive framework for building Semantic Web and Linked Data applications
- Supports a wide range of RDF formats and SPARQL query language
Cons of Jena
- Steeper learning curve due to its extensive feature set
- Can be resource-intensive for large-scale data processing
- Primarily Java-based, which may not be ideal for all development environments
Code Comparison
Atomic Server (Rust):
use atomic_lib::Db;
let db = Db::init("path/to/store").unwrap();
let subject = "https://example.com/resource";
let property = "https://example.com/name";
let value = "John Doe";
db.set_string(subject, property, value, None).unwrap();
Jena (Java):
import org.apache.jena.rdf.model.*;
Model model = ModelFactory.createDefaultModel();
Resource resource = model.createResource("https://example.com/resource");
Property property = model.createProperty("https://example.com/name");
resource.addProperty(property, "John Doe");
While both projects deal with RDF data, Atomic Server focuses on a more modern, lightweight approach using Rust, whereas Jena provides a comprehensive Java-based framework for Semantic Web applications. Atomic Server aims for simplicity and performance, while Jena offers a broader range of features and established standards support.
Convert
designs to code with AI
Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.
Try Visual CopilotREADME
Create, share, fetch and model Atomic Data! AtomicServer is a lightweight, yet powerful CMS / Graph Database. Demo on atomicdata.dev. Docs on docs.atomicdata.dev
This repo also includes:
- Atomic Data Browser, the React front-end for Atomic-Server.
@tomic/lib
JS NPM library.@tomic/react
React NPM library.@tomic/svelte
Svelte NPM library.atomic_lib
Rust library.atomic-cli
terminal client.docs
documentation / specification for Atomic Data (docs.atomicdata.dev).
Status: alpha. Breaking changes are expected until 1.0.
AtomicServer
- ð Fast (less than 1ms median response time on my laptop), powered by actix-web and sled
- 𪶠Lightweight (8MB download, no runtime dependencies)
- ð» Runs everywhere (linux, windows, mac, arm)
- ð§ Custom data models: create your own classes, properties and schemas using the built-in Ontology Editor. All data is verified and the models are sharable using Atomic Schema
- âï¸ Restful API, with JSON-AD responses.
- ð Full-text search with fuzzy search and various operators, often <3ms responses. Powered by tantivy.
- ðï¸ Tables, with strict schema validation, keyboard support, copy / paste support. Similar to Airtable.
- ð Documents, collaborative, rich text, similar to Google Docs / Notion.
- ð¬ Group chat, performant and flexible message channels with attachments, search and replies.
- ð File management: Upload, download and preview attachments.
- ð¾ Event-sourced versioning / history powered by Atomic Commits
- ð Real-time synchronization: instantly communicates state changes with a client. Build dynamic, collaborative apps using websockets (using a single one-liner in react or svelte).
- 𧰠Many serialization options: to JSON, JSON-AD, and various Linked Data / RDF formats (RDF/XML, N-Triples / Turtle / JSON-LD).
- ð Pagination, sorting and filtering queries using Atomic Collections.
- ð Authorization (read / write permissions) and Hierarchical structures powered by Atomic Hierarchy
- ð² Invite and sharing system with Atomic Invites
- ð Embedded server with support for HTTP / HTTPS / HTTP2.0 (TLS) and Built-in LetsEncrypt handshake.
- ð Libraries: Javascript / Typescript, React, Svelte, Rust
https://user-images.githubusercontent.com/2183313/139728539-d69b899f-6f9b-44cb-a1b7-bbab68beac0c.mp4
Documentation
Check out the documentation for installation instructions, API docs, and more.
Contribute
Issues and PRs are welcome! And join our Discord! Read more in the Contributors guide.
Top Related Projects
Solid server on top of the file-system in NodeJS
Apache Jena, A free and open source Java framework for building Semantic Web and Linked Data applications.
Convert
designs to code with AI
Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.
Try Visual Copilot