diff --git a/src/app.html b/src/app.html index baf5602..7c317e0 100644 --- a/src/app.html +++ b/src/app.html @@ -8,8 +8,8 @@ %sveltekit.head% - +
%sveltekit.body%
- + \ No newline at end of file diff --git a/src/routes/+layout.svelte b/src/routes/+layout.svelte index 9293ea5..0385a93 100644 --- a/src/routes/+layout.svelte +++ b/src/routes/+layout.svelte @@ -1,12 +1,25 @@ -
- +
+ {#if $page.url.pathname === '/'} + + {:else} + + {/if}
+ +
+
+ © Copyright 2024-, Tonbo IO. +
+
diff --git a/src/routes/+page.svelte b/src/routes/+page.svelte index ac53e3e..4e37240 100644 --- a/src/routes/+page.svelte +++ b/src/routes/+page.svelte @@ -1,95 +1,86 @@ Tonbo - an extensible embedded database using Arrow. -
+ +
-
-
+
-
-
+
+ Tonbo incurrs minimal cost to insert and scan structured data. +
+
+
+ A portable embedded database using Arrow. +
+
+ +
+
+
-
- A portable embedded database using Arrow. -
+ Read Docs
-
- -
- -
- -
- GitHub Logo -

 Star Us

-
- - -
- Example -
- + + +
+ Example
-
+ +
+
+
+ +
-
-
-
+
+ +
+
Benchmark: range performance
- 
-Random range read with column projection:
-╔═══════════════════════════════════════════════════════════════╗
-║                                                               ║
-║      Tonbo | █████████▓▒                          |  1666ms   ║
-║    RocksDB | ██████████████████████▓▒             |  3689ms   ║
-║       Sled | ███████████████████████▓▒            |  3837ms   ║
-║                                                               ║
-╚═══════════════════════════════════════════════════════════════╝
-(lower is better)                                 Latency (pct99)
-
- 
-CPU: AMD EPYC 7H12
-RAM: 64GB DDR4 2933MHz * 8
-DISK: SamSung 970 EVO Plus 4TB
-
+
-
-

2.2x faster than RocksDB

+
+

+ 2.2x faster than RocksDB +

Because of Tonbo's native support for structured data zero-copy loading and projection pushing down, Tonbo is 2.2x faster than RocksDB. @@ -101,46 +92,48 @@ DISK: SamSung 970 EVO Plus 4TB

+
Just Arrow, Structured, Portable
-
-
-

Vendor lock-in free

-

+ +

+
+

Vendor lock-in free

+

Tonbo is built as a thin wrapper over Arrow schema and Parquet format, which means you are able to use many analytic tools to can fully benefit from the Arrow ecosystem.

-
-

Combine agility of KV and convinient of structured

-

+

-
-

From many sources to many targets

-

+

+

From many sources to many targets

+

As an embedded database, Tonbo supports customizing runtime and file system, and also it is designed for running on kinds of target platforms, we will complete official support WASM / OPFS, Python asyncio and object storages in Sep 2024.

-
- © Copyright 2024-, Tonbo IO. -
diff --git a/src/routes/about/+page.svelte b/src/routes/about/+page.svelte new file mode 100644 index 0000000..e1d7a2a --- /dev/null +++ b/src/routes/about/+page.svelte @@ -0,0 +1,93 @@ + + +
+
+ + +
+
+

+ About Tonbo +

+

+ Tonbo IO was conceived during my time in ByteDance, 2022. I have observed that existing + data processing infrastructure often requires transferring data to centralized vendors for + storage and analysis, limiting true data ownership. Tonbo IO addresses this challenge by + offering an edge-first embedded database that supports data storage and analysis from + local devices to shared storage services, all in open-source formats. +

+ +
+

Contacts

+
+

+ Tzu Gwo: + guozixing@tonbo.io +

+

+ Zeren Li: + lizeren@tonbo.io +

+

+ Ruiwen Cheng: + chengruiwen@tonbo.io +

+
+
+

Credits

+
+
    +
  • + Apache Arrow + / Parquet: + open-source data / file formats supports storing data to numerous storage services, it + help us avoiding vendor lock-in. +
    • +
  • + RocksDB: a state-of-art embedded database, RocksDB inspires Tonbo on building a high + performance columnar database on LSM Tree. +
    • +
  • + mini-lsm: an educational project implementing LSM Trees in Rust. The exploration of Rust's + type system and efficient LSM Tree implementation in this project inspired the + abstract type design in Tonbo. +
    • +
  • + sled: + an embedded database written in Rust, its API and modular project structure design + impact us. +
    • +
  • + redb: + an embedded key-value store in Rust, Tonbo built early stage benchmarks upon its + cases. +
    • +

    + Also thanks to all of Tonbo's community contributors, their support and dedication make this project possible. And thanks to + @Cream Tang, who + designed the web and the logo. +

    +
+
+
+
+
+
diff --git a/src/routes/benchmark-chart.svelte b/src/routes/benchmark-chart.svelte new file mode 100644 index 0000000..d69de4d --- /dev/null +++ b/src/routes/benchmark-chart.svelte @@ -0,0 +1,83 @@ + + +
+ {#each data as item} +
+
{item.name}
+
+
{item.bar}
+
+
{item.value}ms
+
+ {/each} +
+

(lower is better)

+

Latency (pct99)

+
+
+

CPU: AMD EPYC 7H12

+

RAM: 64GB DDR4 2933MHz * 8

+

DISK: SamSung 970 EVO Plus 4TB

+
+
+ + diff --git a/src/routes/blog/introducing-tonbo/+page.svelte b/src/routes/blog/introducing-tonbo/+page.svelte index 83b900a..ece1e86 100644 --- a/src/routes/blog/introducing-tonbo/+page.svelte +++ b/src/routes/blog/introducing-tonbo/+page.svelte @@ -16,74 +16,78 @@ pub struct User { `; -
-
-
+
-

Intoducing Tonbo

-

August 14, 2024 by Tzu Gwo

-

- We’re excited to announce that Tonbo is now open source in its preview version! Tonbo is an embedded persistent database written in - Rust. It provides essential KV-like methods: insert, filter, and range scan, making it a foundation - for data-intensive applications, including other types of databases. It also supports type-safe - structured data storage. For Rust developers, we offer an ORM-like macro for ease of use: -

- -

-

- Tonbo enables fast and convenient querying over type-safe structured data. For example, - integrating a query engine takes just a few hours of coding: datafusion example - (official support for DataFusion will be included in the next release). In our preliminary benchmarks, - Tonbo outperforms RocksDB by 2.2x in data scan scenarios, even though it's still in its early stages. - If you’re interested in Tonbo, please star the project on GitHub, follow us on - Twitter, or join the conversation on - Discord. -

-

Why We Built Tonbo?

-

- Analytical tools in the Apache Arrow - (such as - Apache Arrow DataFusion ecosystems provide an nice foundation for data processing. They get a great balance between scalability, - development efficiency, and execution performance, allowing developers to build efficient data - analysis applications within days using DataFusion. -

-

- However, most tools are focus on the read path of databases. Every data-intensive application - using DataFusion ends up spending significant time developing its own write path - implementation. What if we could have a write path implementation as agile and performant as - DataFusion? -

-

- That’s the primary design goal of Tonbo: to serve as an embedded database offering a highly - scalable data storage engine for the Arrow ecosystem. Additionally, Tonbo also has a long-term - goal: provide offline-first distributed data storage capabilities, support rapid and flexible - data storage across various environments—from embedded Linux and browsers to servers—and - integrating with multiple storage systems such as file systems, OPFS, and S3. -

- 
+		

+			

+				
Intoducing Tonbo

+				
August 14, 2024 by Tzu Gwo

+			

+			

+				We’re excited to announce that Tonbo is now open source in its preview version! Tonbo is an embedded persistent database written
+				in Rust. It provides essential KV-like methods: insert, filter, and range scan, making it a foundation
+				for data-intensive applications, including other types of databases. It also supports type-safe
+				structured data storage. For Rust developers, we offer an ORM-like macro for ease of use:
+			

+			
+			

+			

+				Tonbo enables fast and convenient querying over type-safe structured data. For example,
+				integrating a query engine takes just a few hours of coding: datafusion example
+				(official support for DataFusion will be included in the next release). In our preliminary benchmarks,
+				Tonbo outperforms RocksDB by 2.2x in data scan scenarios, even though it's still in its early
+				stages. If you’re interested in Tonbo, please star the project on GitHub, follow us on
+				Twitter, or join the conversation on
+				Discord.
+			

+			
Why We Built Tonbo?

+			

+				Analytical tools in the Apache Arrow
+				(such as
+				Apache Arrow DataFusion ecosystems provide an nice foundation for data processing. They get a great balance between
+				scalability, development efficiency, and execution performance, allowing developers to build
+				efficient data analysis applications within days using DataFusion.
+			

+			

+				However, most tools are focus on the read path of databases. Every data-intensive
+				application using DataFusion ends up spending significant time developing its own write path
+				implementation. What if we could have a write path implementation as agile and performant as
+				DataFusion?
+			

+			

+				That’s the primary design goal of Tonbo: to serve as an embedded database offering a highly
+				scalable data storage engine for the Arrow ecosystem. Additionally, Tonbo also has a
+				long-term goal: provide offline-first distributed data storage capabilities, support rapid and flexible
+					data storage across various environments—from embedded Linux and browsers to servers—and
+					integrating with multiple storage systems such as file systems, OPFS, and S3.
+			

+			

+				
 
 			╔═tonbo═════════════════════════════════════════════════════╗
 			║                                                           ║
@@ -118,57 +122,61 @@ pub struct User {
 			║    └──────────────────────────────────────────────────┘   ║
 			║                                                           ║
 			╚═══════════════════════════════════════════════════════════╝
-		

-		
How is Tonbo Designed?

-		
LSM Tree

-		

-			Tonbo is built on the LSM Tree
-			architecture. Typically, databases use either
-			Log-Structured Merge (LSM) trees or B+ trees. The primary advantage of LSM trees is that all foreground writes are performed in memory,
-			while background writes are sequential, resulting in very high write throughput.
-		

+
+
+

How is Tonbo Designed?

+

LSM Tree

+

+ Tonbo is built on the LSM Tree + architecture. Typically, databases use either + Log-Structured Merge (LSM) trees or B+ trees. The primary advantage of LSM trees is that all foreground writes are performed in memory, + while background writes are sequential, resulting in very high write throughput. +

-

- LSM trees also have minimal file system requirements: they only need a file system that - supports append-only operations to achieve high-performance data insertion and updates. This - makes Tonbo suitable for a wide range of devices, from flash storage to SSDs. By offloading - tasks like data clean-up and compaction to the background, LSM trees streamline the read/write - process and reduce the load on the frontend. -

-

Type-Safe Structured Storage

-

- As mentioned earlier, Tonbo extends beyond a traditional KV database to support reading and - writing structured data. This capability is achieved by faithfully translating user-defined - data structures into Arrow schemas. Tonbo leverages the features provided by Arrow/Parquet to - support pushdown operations like limit, project, and filter: -

- -

- This means that Tonbo can precisely scan the data specified by the use, and skipping - irrelevant data, leading to potentially more than tenfold improvements in querying efficiency - when used appropriately. Additionally, according to compile-time type hint, Tonbo can - transmute bytes read from files into user-defined data types free. In many data-intensive - applications, serialization overhead can account for 30% to 50% of the total load. -

-

Asynchronous

-

Tonbo fully supports asychronous methods:

- -

- Using asynchronous interfaces not only increases the efficiency of concurrent operations, but - also allows Tonbo to provide concurrent access on resource-constrained devices, such as - browsers, mobile apps, and embedded Linux systems. The LSM Tree architecture, as mentioned in - previous sections, requires background tasks for garbage collection and compaction newly - written data, which can be challenging to implement in browsers since they cannot easily start - background tasks. By leveraging WASM and async Rust interfaces, we can build a complete - asynchronous task chain from OPFS to the JavaScript scheduler. In our upcoming blog posts, we - will describe in detail how we achieve this—bear witness! -

- 
+			

+				LSM trees also have minimal file system requirements: they only need a file system that
+				supports append-only operations to achieve high-performance data insertion and updates. This
+				makes Tonbo suitable for a wide range of devices, from flash storage to SSDs. By offloading
+				tasks like data clean-up and compaction to the background, LSM trees streamline the
+				read/write process and reduce the load on the frontend.
+			

+			
Type-Safe Structured Storage

+			

+				As mentioned earlier, Tonbo extends beyond a traditional KV database to support reading and
+				writing structured data. This capability is achieved by faithfully translating user-defined
+				data structures into Arrow schemas. Tonbo leverages the features provided by Arrow/Parquet
+				to support pushdown operations like limit, project, and filter:
+			

+			
+			

+				This means that Tonbo can precisely scan the data specified by the use, and skipping
+				irrelevant data, leading to potentially more than tenfold improvements in querying
+				efficiency when used appropriately. Additionally, according to compile-time type hint, Tonbo
+				can transmute bytes read from files into user-defined data types free. In many
+				data-intensive applications, serialization overhead can account for 30% to 50% of the total
+				load.
+			

+			
Asynchronous

+			
Tonbo fully supports asychronous methods:

+			
+			

+				Using asynchronous interfaces not only increases the efficiency of concurrent operations,
+				but also allows Tonbo to provide concurrent access on resource-constrained devices, such as
+				browsers, mobile apps, and embedded Linux systems. The LSM Tree architecture, as mentioned
+				in previous sections, requires background tasks for garbage collection and compaction newly
+				written data, which can be challenging to implement in browsers since they cannot easily
+				start background tasks. By leveraging WASM and async Rust interfaces, we can build a
+				complete asynchronous task chain from OPFS to the JavaScript scheduler. In our upcoming blog
+				posts, we will describe in detail how we achieve this—bear witness!
+			

+			

+				
 
 						╔═Web APP══════════════════════╗
 						║                              ║
@@ -188,19 +196,22 @@ pub struct User {
 						║ ┃ ┗╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍┅┛ ┃ ║
 						║ ┗━━━━━━━━━━━━━━━━━━━━━━━━━━┛ ║
 						╚══════════════════════════════╝
-		

-		
Futures and Promises

-		
As we prepare for our next release, we plan to introduce several new features:

-		
	• Runtime Schema Declaration: Basic support for JavaScript (WASM) and Python.

-		
	• S3 Integration: Implementation of tiered LSM Trees based on this integration.

-		

-			We will soon offer a unified solution for both self-hosted and cloud environments, enabling
-			the creation of offline-first storage and backup services on any remote storage platform.
-			Designs and implementations are only valuable with real-world usage and feedback. If you
-			believe our work could benefit you, please reach out directly. We’re excited to collaborate
-			and provide any assistance we can.
-		

-
+ +
+ +

Futures and Promises

+

As we prepare for our next release, we plan to introduce several new features:

+ 
	• Runtime Schema Declaration: Basic support for JavaScript (WASM) and Python.
+ 
	• S3 Integration: Implementation of tiered LSM Trees based on this integration.
+

+ We will soon offer a unified solution for both self-hosted and cloud environments, enabling + the creation of offline-first storage and backup services on any remote storage platform. + Designs and implementations are only valuable with real-world usage and feedback. If you + believe our work could benefit you, please reach out directly. We’re excited to collaborate + and provide any assistance we can. +

+ +
diff --git a/src/routes/blog/introducing-tonbo/old-page.svelte b/src/routes/blog/introducing-tonbo/old-page.svelte new file mode 100644 index 0000000..bc52151 --- /dev/null +++ b/src/routes/blog/introducing-tonbo/old-page.svelte @@ -0,0 +1,204 @@ + + +
+
+
+

Intoducing Tonbo

+

August 14, 2024 by Tzu Gwo

+

+ We’re excited to announce that Tonbo is now open source in its preview version! Tonbo is an embedded persistent database written in + Rust. It provides essential KV-like methods: insert, filter, and range scan, making it a foundation + for data-intensive applications, including other types of databases. It also supports type-safe + structured data storage. For Rust developers, we offer an ORM-like macro for ease of use: +

+ +

+

+ Tonbo enables fast and convenient querying over type-safe structured data. For example, + integrating a query engine takes just a few hours of coding: datafusion example + (official support for DataFusion will be included in the next release). In our preliminary benchmarks, + Tonbo outperforms RocksDB by 2.2x in data scan scenarios, even though it's still in its early stages. + If you’re interested in Tonbo, please star the project on GitHub, follow us on + Twitter, or join the conversation on + Discord. +

+

Why We Built Tonbo?

+

+ Analytical tools in the Apache Arrow + (such as + Apache Arrow DataFusion ecosystems provide an nice foundation for data processing. They get a great balance between scalability, + development efficiency, and execution performance, allowing developers to build efficient data + analysis applications within days using DataFusion. +

+

+ However, most tools are focus on the read path of databases. Every data-intensive application + using DataFusion ends up spending significant time developing its own write path + implementation. What if we could have a write path implementation as agile and performant as + DataFusion? +

+

+ That’s the primary design goal of Tonbo: to serve as an embedded database offering a highly + scalable data storage engine for the Arrow ecosystem. Additionally, Tonbo also has a long-term + goal: provide offline-first distributed data storage capabilities, support rapid and flexible + data storage across various environments—from embedded Linux and browsers to servers—and + integrating with multiple storage systems such as file systems, OPFS, and S3. +

+ 
+
+			╔═tonbo═════════════════════════════════════════════════════╗
+			║                                                           ║
+			║    ┌─────────client memory─┐  ┌─────────client memory─┐   ║
+			║    │ ┏━━━━━━━━━━━━┓        │  │ ┏━━━━━━━━━━━━┓        │   ║
+			║    │ ┃  memtable  ┃        │  │ ┃  memtable  ┃        │   ║
+			║    │ ┗━━━━┳━━━━━━━┛        │  │ ┗━━━━┳━━━━━━━┛        │   ║
+			║    │ ┏━━━━▼━━━━━━━┓        │  │ ┏━━━━▼━━━━━━━┓        │   ║
+			║    │ ┃  memtable  ┃        │  │ ┃  memtable  ┃        │   ║
+			║    │ ┗━━━━┳━━━━━━━┛        │  │ ┗━━━━┳━━━━━━━┛        │   ║
+			║    │ ┏━━━━▼━━━━━━━┓        │  │ ┏━━━━▼━━━━━━━┓        │   ║
+			║    │ ┃  memtable  ┃        │  │ ┃  memtable  ┃        │   ║
+			║    │ ┗━━━━┳━━━━━━━┛        │  │ ┗━━━━┳━━━━━━━┛        │   ║
+			║    └──────╂────────────────┘  └──────╂────────────────┘   ║
+			║    ┌──────╂─client storage─┐  ┌──────╂─client storage─┐   ║
+			║    │ ┏━━━━▼━━━━┓           │  │ ┏━━━━▼━━━━┓           │   ║
+			║    │ ┃ parquet ┃           │  │ ┃ parquet ┃           │   ║
+			║    │ ┗━━━━┳━━━━┛           │  │ ┗━━━━┳━━━━┛           │   ║
+			║    └──────╂────────────────┘  └──────╂────────────────┘   ║
+			║           ┣━━━━━━━━━━━━━━━━━━━━━━━━━━┛                    ║
+			║    ┌──────╂────────────────────────────────server ssd─┐   ║
+			║    │      ┣━━━━━━━━━━━┓                               │   ║
+			║    │ ┏━━━━▼━━━━┓ ┏━━━━▼━━━━┓                          │   ║
+			║    │ ┃ parquet ┃ ┃ parquet ┃                          │   ║
+			║    │ ┗━━━━┳━━━━┛ ┗━━━━┳━━━━┛                          │   ║
+			║    └──────╂───────────╂───────────────────────────────┘   ║
+			║    ┌──────╂───────────╂────────object storage service─┐   ║
+			║    │      ┣━━━━━━━━━━━╋━━━━━━━━━━━┳━━━━━━━━━━━┓       │   ║
+			║    │ ┏━━━━▼━━━━┓ ┏━━━━▼━━━━┓ ┏━━━━▼━━━━┓ ┏━━━━▼━━━━┓  │   ║
+			║    │ ┃ parquet ┃ ┃ parquet ┃ ┃ parquet ┃ ┃ parquet ┃  │   ║
+			║    │ ┗━━━━━━━━━┛ ┗━━━━━━━━━┛ ┗━━━━━━━━━┛ ┗━━━━━━━━━┛  │   ║
+			║    └──────────────────────────────────────────────────┘   ║
+			║                                                           ║
+			╚═══════════════════════════════════════════════════════════╝
+
+

How is Tonbo Designed?

+

LSM Tree

+

+ Tonbo is built on the LSM Tree + architecture. Typically, databases use either + Log-Structured Merge (LSM) trees or B+ trees. The primary advantage of LSM trees is that all foreground writes are performed in memory, + while background writes are sequential, resulting in very high write throughput. +

+ +

+ LSM trees also have minimal file system requirements: they only need a file system that + supports append-only operations to achieve high-performance data insertion and updates. This + makes Tonbo suitable for a wide range of devices, from flash storage to SSDs. By offloading + tasks like data clean-up and compaction to the background, LSM trees streamline the read/write + process and reduce the load on the frontend. +

+

Type-Safe Structured Storage

+

+ As mentioned earlier, Tonbo extends beyond a traditional KV database to support reading and + writing structured data. This capability is achieved by faithfully translating user-defined + data structures into Arrow schemas. Tonbo leverages the features provided by Arrow/Parquet to + support pushdown operations like limit, project, and filter: +

+ +

+ This means that Tonbo can precisely scan the data specified by the use, and skipping + irrelevant data, leading to potentially more than tenfold improvements in querying efficiency + when used appropriately. Additionally, according to compile-time type hint, Tonbo can + transmute bytes read from files into user-defined data types free. In many data-intensive + applications, serialization overhead can account for 30% to 50% of the total load. +

+

Asynchronous

+

Tonbo fully supports asychronous methods:

+ +

+ Using asynchronous interfaces not only increases the efficiency of concurrent operations, but + also allows Tonbo to provide concurrent access on resource-constrained devices, such as + browsers, mobile apps, and embedded Linux systems. The LSM Tree architecture, as mentioned in + previous sections, requires background tasks for garbage collection and compaction newly + written data, which can be challenging to implement in browsers since they cannot easily start + background tasks. By leveraging WASM and async Rust interfaces, we can build a complete + asynchronous task chain from OPFS to the JavaScript scheduler. In our upcoming blog posts, we + will describe in detail how we achieve this—bear witness! +

+ 
+
+						╔═Web APP══════════════════════╗
+						║                              ║
+						║ ┏━JS microtasks━━━━━━━━━━━━┓ ║
+						║ ┃                          ┃ ║
+						║ ┃ ┏╍WASM binding╍╍╍╍╍╍╍╍╍┓ ┃ ║
+						║ ┃ ┇                      ┇ ┃ ║
+						║ ┃ ┇ ┏━Tonbo async API━━┓ ┇ ┃ ║
+						║ ┃ ┇ ┃                  ┃ ┇ ┃ ║
+						║ ┃ ┇ ┃ ┏╍WASM binding╍┓ ┃ ┇ ┃ ║
+						║ ┃ ┇ ┃ ┇              ┇ ┃ ┇ ┃ ║
+						║ ┃ ┇ ┃ ┇   ┏━━━━━━┓   ┇ ┃ ┇ ┃ ║
+						║ ┃ ┇ ┃ ┇   ┃ OPFS ┃   ┇ ┃ ┇ ┃ ║
+						║ ┃ ┇ ┃ ┇   ┗━━━━━━┛   ┇ ┃ ┇ ┃ ║
+						║ ┃ ┇ ┃ ┗╍╍╍╍╍╍╍╍╍╍╍╍╍╍┛ ┃ ┇ ┃ ║
+						║ ┃ ┇ ┗━━━━━━━━━━━━━━━━━━┛ ┇ ┃ ║
+						║ ┃ ┗╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍╍┅┛ ┃ ║
+						║ ┗━━━━━━━━━━━━━━━━━━━━━━━━━━┛ ║
+						╚══════════════════════════════╝
+
+

Futures and Promises

+

As we prepare for our next release, we plan to introduce several new features:

+ 
	• Runtime Schema Declaration: Basic support for JavaScript (WASM) and Python.
+ 
	• S3 Integration: Implementation of tiered LSM Trees based on this integration.
+

+ We will soon offer a unified solution for both self-hosted and cloud environments, enabling + the creation of offline-first storage and backup services on any remote storage platform. + Designs and implementations are only valuable with real-world usage and feedback. If you + believe our work could benefit you, please reach out directly. We’re excited to collaborate + and provide any assistance we can. +

+
+
diff --git a/src/routes/blogs/+page.svelte b/src/routes/blogs/+page.svelte new file mode 100644 index 0000000..8afe527 --- /dev/null +++ b/src/routes/blogs/+page.svelte @@ -0,0 +1,85 @@ + + +
+
+ +
+ +
+ + + +
+
+

Intorucing Tonbo

 +
+
+

+ We’re excited to announce that Tonbo is now open source in its preview version! Tonbo + is an embedded persistent database written in Rust. It provides essential KV-like + methods: insert, filter, and range scan, making it a foundation for data-intensive + applications, including other types of databases. It also supports type-safe + structured data storage. For Rust developers, we offer an ORM-like macro for ease of + use... Read more → +

+

2024/08/14

+
+
+
+
+ +
+
+

Async Rust is not safe with io_uring

 +
+
+

+ Barbara had a lot of experience developing web services with async Rust. One day, she + read a blog about io_uring, which described it as the next-generation async I/O + interface for Linux. Interested, Barbara decided to try it out in her sidecar web + service...  Read more → +

+

2024/08/14

+
+
+
+
+
+
diff --git a/src/routes/dragonfly.svelte b/src/routes/dragonfly.svelte index 6d2d8e9..9d0b4a5 100644 --- a/src/routes/dragonfly.svelte +++ b/src/routes/dragonfly.svelte @@ -1,5 +1,6 @@ 
██████████████████████████
+	class="{$$props.class} font-code scale-y-[0.8] origin-bottom leading-[1.25] text-tonbo-red bg-background-light"
+	data-svelte-h="svelte-aqwz3a">██████████████████████████
 ██████████████████████████
 ██████████████████████████
 ██████████████████████████
diff --git a/src/routes/header.svelte b/src/routes/header.svelte
new file mode 100644
index 0000000..475a4d4
--- /dev/null
+++ b/src/routes/header.svelte
@@ -0,0 +1,13 @@
+
+
+

+	

+		
+	

+	
{title}

+

diff --git a/src/routes/home-navigator.svelte b/src/routes/home-navigator.svelte
new file mode 100644
index 0000000..8157886
--- /dev/null
+++ b/src/routes/home-navigator.svelte
@@ -0,0 +1,78 @@
+
+
+
diff --git a/src/routes/navigator.svelte b/src/routes/navigator.svelte
index c6370df..f84e164 100644
--- a/src/routes/navigator.svelte
+++ b/src/routes/navigator.svelte
@@ -2,56 +2,74 @@
 	import Tonbo from './tonbo.svelte';
 	import XLogo from '$lib/images/x-logo.png';
 	import DiscordLogo from '$lib/images/discord-logo.png';
+	import GitHubLogo from '$lib/images/github-logo.svg';
 
 
 
diff --git a/src/routes/tonbo.svelte b/src/routes/tonbo.svelte
index 44fc875..0dee920 100644
--- a/src/routes/tonbo.svelte
+++ b/src/routes/tonbo.svelte
@@ -1,4 +1,6 @@
-
███▀█████████████▀████████
+

+	
███▀█████████████▀████████
 ██▄ ▄██▀▄ ██ ▄▀██ ▄ ██ ▄▀█
 ███▄▄██▄▄███▄█▄██▄▄████▄▄█

+

diff --git a/src/styles/blogs.css b/src/styles/blogs.css
new file mode 100644
index 0000000..38e73a1
--- /dev/null
+++ b/src/styles/blogs.css
@@ -0,0 +1,7 @@
+.apply-blog-base {
+  @apply md:w-[914px] md:px-0 px-2 sm:px-0 sm:w-[600px] py-6 min-h-full m-auto;
+}
+
+.apply-blog-block {
+  @apply px-8 md:px-12 py-4 border-black border-[1px] md:border-2;
+}
\ No newline at end of file
diff --git a/src/styles/home.css b/src/styles/home.css
new file mode 100644
index 0000000..2b708b9
--- /dev/null
+++ b/src/styles/home.css
@@ -0,0 +1,34 @@
+/* Common container styles */
+.apply-container-base {
+  @apply w-full mx-auto bg-background-dark;
+}
+
+.apply-container-responsive {
+  @apply sm:w-[600px] md:w-[1000px] lg:w-[1200px];
+}
+
+/* Selection styles */
+.apply-selection {
+  @apply selection:bg-background-light selection:text-background-dark;
+}
+
+/* Border styles */
+.apply-border {
+  @apply border-2 border-background-light;
+}
+
+
+/* Button-like styles */
+.apply-button-base {
+  @apply flex items-center justify-center p-2 text-base cursor-pointer select-none;
+}
+
+/* Article styles */
+.apply-article-base {
+  @apply mx-[2rem] md:mx-1 px-2 py-8 flex-1 md:px-12 md:py-0 md:my-12;
+}
+
+/* Heading styles */
+.apply-heading {
+  @apply mb-4 text-lg font-medium leading-normal text-center md:text-2xl;
+}
\ No newline at end of file
diff --git a/src/styles/layout.css b/src/styles/layout.css
new file mode 100644
index 0000000..6c36e9d
--- /dev/null
+++ b/src/styles/layout.css
@@ -0,0 +1,15 @@
+.apply-navigator-base {
+  @apply font-code w-full mx-auto flex justify-between bg-background-dark pt-[2rem] pb-[2rem] flex-col sm:flex-row relative;
+}
+
+.apply-navigator-responsive {
+  @apply sm:w-[600px] md:w-[1000px] lg:w-[1200px];
+}
+
+.apply-home-navigator {
+  @apply py-10 h-[183px] lg:h-[103px] md:h-[103px];
+}
+
+.apply-regular-navigator {
+  @apply px-8 h-[151px] md:h-[116px];
+}
\ No newline at end of file
diff --git a/tailwind.config.js b/tailwind.config.js
index 5238891..b5d0091 100644
--- a/tailwind.config.js
+++ b/tailwind.config.js
@@ -1,8 +1,14 @@
 /** @type {import('tailwindcss').Config} */
 export default {
-  content: ['./src/**/*.{html,js,svelte,ts}', './node_modules/svhighlight/**/*.svelte'],
+  content: [ './src/**/*.{html,js,svelte,ts}', './node_modules/svhighlight/**/*.svelte' ],
   theme: {
     extend: {
+      screens: {
+        'xs': '480px',
+        'sm': '640px',
+        'md': '1200px',
+        'lg': '1400px',
+      },
       colors: {
         "background-dark": "#222623",
         "background-light": "#E7F1BE",
@@ -13,8 +19,8 @@ export default {
       }
     },
     fontFamily: {
-      code: ["Iosevka Web", "monospace"],
-      medium: ["Iosevka Web Medium", "monospace"],
+      code: [ "Iosevka Web", "monospace" ],
+      medium: [ "Iosevka Web Medium", "monospace" ],
     },
   },
   plugins: [],