EVNT

Events are complicated. Modern applications always make assumptions about the structure of events, which makes it difficult to represent certain types of events. The ICAL format is old and outdated, and it is not designed to be flexible or extensible.

Unlike iCal, Evnt uses JSON at its core. Almost every language has good support for JSON, and it is easy to work with.

Evnt is designed to be flexible and extensible, allowing users to represent any type of event in a consistent way while allowing for future extensions.

Unfortunately this does mean that Evnt is more complex than iCal and that it will not be adopted by everyone.

And yes, this does mean XKCD 927.

• Multilingual - Every text field in Evnt supports multiple languages (by using language-keyed objects). This means that internationalization is built into the core of the format.

  {
    "en": "Example message",
    "lt": "Pavyzdžio pranešimas"
  }

• Instances - Events can have multiple time spans. Many events (e.g. conferences) have multiple instances, and it is important to be able to represent that in a consistent way.
• Venues - Events can have multiple venues, both physical and online. This is important for events that have multiple physical locations (e.g. a conference with multiple stages) or that are hybrid (e.g. a conference with both physical and online attendees).
• Partial Dates - Some events only have partial date information. For example, you might only know the month and year of an event, but not the exact day. Evnt allows you to represent this in a consistent way by allowing partial date strings (e.g. "2024-05" for May 2024).
• No Timezones - Everything is stored in UTC, and it's up to the application to convert it to the user's local timezone.
• Metadata - Information that don't belong to a specific instance or venue can be stored as Components, which are extensible.

  We currently have:

  • Links - Links related to the event (e.g. website, social media, registration form etc.); they can have titles, descriptions and even defined times for when they are valid.
  • Splash Media - Images or videos that represent the event. Applications can use this to display a banner for the event, for example.

  Components can also be defined by applications, and they can be used to store any kind of metadata that doesn't fit into the predefined fields.

Evnt is still a relatively new project, so there aren't many applications using it yet.

Applications using evnt

Application	Description		Source
Vantage	Default, reference implementation of an event viewer	/	Link

These applications all support the eventsl.ink link format which allows you to share links to your events that can be opened in any of these applications.

If you're building an application using Evnt, please let us know!

You can find the specification for Evnt in docs/README.md file in the GitHub repository.

We have a npm package for the schema that uses Zod and provides TypeScript types as well as runtime validation. You can find it on npm as @evnt/schema.

pnpm add @evnt/schema

We also auto-generate a couple things using the @evnt/schema code:

• A JSON Schema for the event data, which can be used for validation and type generation. You can find it in event-data.schema.json. Here's a raw link you can use as $schema:

https://raw.githubusercontent.com/deniz-blue/events-format/refs/heads/main/event-data.schema.json
Expand code

• A markdown document that documents all the type information.

The Evnt format is compatible with ATProto.

Applications should use the directory.evnt.event collection for events.

You can find the lexicons below. Lexicon version 1 does not support the neccesary features to fully represent the evnt schema, so this is a very rough approximation.

Currently the standard collection for events is the community.lexicon.calendar.event lexicon. Unfortunately, Evnt is more complex so these two lexicons are not fully compatible.

Applications wishing to support both lexicons can use the same TID and do conversion between the formats.

The community.lexicon.calendar.rsvp lexicons can be used for RSVPs since subject field is a com.atproto.repo.strongRef and allows referencing the event in the directory.evnt.event collection.

Here is a comparison table showing how Evnt compares to some other event formats:

We don't want to overrate our own format so feel free to point out things to add here.

Here is a couple of code examples of evnt events:

{
  "v": 0,
  "name": {
    "en": "No venues"
  },
  "instances": [
    {
      "venueIds": [],
      "start": "2027-03-08T09:00",
      "end": "2027-03-08T18:00"
    }
  ]
}

Use the section below to validate JSON in the format

Preview