Chronicle: Historical Database of ETH Events

Hello Gardeners!

The number of ETH* events has grown incredibly recently, so it would be a good idea to start categorizing and archiving information about these events for future generations. Every event can be considered a unique piece of art in some way, not only because of the graphic design or content, but also the atmosphere.

At the same time, we would like to make it as open as possible, where anyone can edit or add to the data and distribute the data as decentralized as possible.

I have already started implementing this project - the working title is chronicle. See below for more information.

Collected data

  • basic event data (name, date and time, venue, links…)
  • attendance data (expected and real)
  • contributors (speakers, mentors, judges, team…)
  • partners and sponsors: how the event was funded
  • event web - archiving like
  • graphic content - logos, posters and other materials
  • data about each talk, workshop, etc.
  • hackathon: details about the hackathon (number of hackers, projects, prizes, bounties, platform…)
  • post-event materials: photos, videos (aftermovie…)

MVP Implementation


MVP frontend is created using Astro, Svelte & Tailwind (source code).

The application can be found at:

Example: EthereumZurich 2023, ETHBerlin³, ETHBrno²



I decided to start simple, so I created a GitHub repository where the information is stored in YAML files, and builded into single JSON, which can be easily stored on IPFS or other distributed storage, link below:


The source data is stored in YAML format in the ./data directory.

Schema is defined in JSON Schema format, definitions can be found in the ./schema directory, e.g. ./schema/event.yaml.

Output can be consumed as single JSON at this URL:


Collection Schema Description
event event.yaml Particular event
family family.yaml Family of events (for example ETHGlobal)
series series.yaml Series of events in chronological order (for example ETHPrague, ETHBerlin…)


The build into a single JSON bundle is done using scripts written in Javascript, executed via Deno runtime & makefile.

Event example - index.yaml

Here is an example of the definition of a specific event (source):

name: EthereumZurich
series: ethereumzurich
types: [ conference, hackathon ]
date: "2023-04-14"
days: 3
place: Zurich
region: europe
country: ch
host_name: DuckTape/PWN
attendees: 800
attendees_real: 489
  hackers: 100
  hackers_real: 71
  hacker_application_platform: typeform
  projects: 16
  project_submission_platform: devfolio
  prizes_total: 5000 USD
    - name: Open track - quadratic voting [1st place]
      amount: 1500 USD
    - name: Open track - quadratic voting [2st place]
      amount: 1000 USD
    - name: Open track - quadratic voting [3st place]
      amount: 500 USD
    - name: Judges' favourites [1st place]
      amount: 2000 USD
  bounties_total: 3750 USD
    - name: Gelato Web3 Functions
      amount: 750 USD
    - name: DataverseOS Web3 Functions
      amount: 1000 USD
    - name: API3 DAO - Use of first-party oracles
      amount: 1000 USD
    - name: PWN bounty
      amount: 1000 USD
1 Like

Here is a list of issues or tasks we need to address.

I will be very happy for discussion and every comment, every single topic mention below is important.

1. Specify what we want in the database (schema)

I have designed a basic schema for models and properties, you can find it in the repository in the schema directory, but there are still a lot of things missing. We need to finish the schema for everything we want to collect as soon as possible, because the subsequent additions to the database will depend on it.

Task for you: think which fields we need, or what data to collect and post it here in the thread, or implement it directly in the schema.

2. Build the basic frontend

As I wrote, I’m working on a prototype (, but I’m not really a web designer, so it’s slow going and I could use your help. There’s not much work done yet, so it’s easy to start from scratch and build it on other technologies, if needed.

Besides the real implementation of the frontend, it is also necessary to have a plan of what we want to have there, which you can also help me with. If you are designers or UX wizards, we would be glad to help :slight_smile:

3. Complete the event database

This will be the hardest task that never ends :slight_smile: We need to add information about events from the past while keeping track of new events and maintaining this whole list. Partly it can work automatically through PR (pull requests), or helper scripts that download for example speakers and other information, but most of the data and basic configuration will have to be supplied manually.

We currently have the base for 100 events in our database and extensive details for only few of them. We will need at least 5 people who will be willing to keep this data repository maintained and running.

4. “2023 ETH Events Coordination” and other groups - replacing the custom list’s

If we already have an extensive & maintained database of all ETH* events, this can replace the various lists in coordination groups such as the “2023 ETH Events Coordination” group.

5. Decide how to store big files like photos or videos (or just how to store everything)

I am in favour of progressive decentralisation. For start, having the core JSON data in a repository on GitHub that we’ll mirror. The question is where to store large files like photos or videos. We’ll probably also use our own hosting for that at first, but would like to get that sorted out as soon as possible.

As an endgoal, it could be to store everything in decentralized manner - basic data (JSON) on a decentralized Arweave (as its permanent) and large files on a distributed IPFS… or Filecoin, Swarm or something similar (as its distributed and immutable). Also frontend can be easily hosted on IPFS as or similar.