CLI tool
ccfddl/ccf-deadlines avatar
ccfddl/ccf-deadlines

ccf-deadlines: A YAML Repository Behind a Conference Deadline Tracker

⏰ Agenticly track worldwide conference deadlines (Website, Python Cli, Wechat Applet)

9,544 stars637 forksRustMIT

At a glance

What is it?
ccfddl/ccf-deadlines is a collaborative YAML database of CCF-ranked conference deadlines, rendered by a Leptos WebAssembly client and reachable through a Python CLI, iCal feed, Raycast extension, Chrome extension and WeChat applet. It suits researchers who want one timezone-normalised deadline list, not people expecting a managed service.
Who is it for?
Adopt ccf-deadlines if you want a single timezone-normalised deadline list you can subscribe to or query from a terminal, and if you are willing to send a pull request when an entry is wrong. Do not adopt it if you need guaranteed notification delivery or a supported commercial data feed; the repository is a community dataset with no published GitHub releases.
Can I use it commercially?
Yes. MIT is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
Is it still maintained?
Yes. The repository received new commits within the last day.
What is it written in?
Mainly Rust, according to GitHub's language statistics.

Answers come from the project's GitHub data, last synced on November 15, 2026, and from our analysis. They are not legal advice.

From daily snapshots

Star history

  • ccfddl/ccf-deadlines9,544 ★ · +189
Star history
Repository2026-09-222026-11-15
ccfddl/ccf-deadlines9.4k9.5k

189 Stars in the last 54 days, measured from the daily GitHub snapshot. Compare with other projects

Editorial analysis

What ccf-deadlines actually is: a YAML dataset with clients on top

The project solves a narrow, recurring problem: a researcher decides which conferences to target, then spends an afternoon opening a dozen homepages to find submission dates, and converts each one out of its local timezone by hand. ccf-deadlines collects those dates into per-conference YAML files and renders them through several front ends.

The README states the goal plainly: "Helping researchers track worldwide conference ddls through (agentic) collaboration." That word, collaboration, is the design centre. Every conference is a file in `conference/<sub>/<name>.yml`, and the contribution path in the README is to fork the repository, add or update the yml file, and send a pull request. There is no submission form and no editor account.

Who it is for: PhD students and faculty who already think in CCF ranks, and who want the rank, the deadline and the conference location in one place. Who it is not for: anyone who needs an SLA, an audit trail, or a notification that fires even when their laptop is closed. The site is a static client; the data is whatever the last merged pull request said.

The repository is not archived. Its last push was on 2026-11-02, so the dataset is being touched, but the pull-request model means freshness varies by conference file rather than by project.

How the deadline data flows from yml to your screen

The architecture is a static pipeline with a client-side renderer. Conference records live in `conference/`, one directory per CCF subject area, one YAML file per conference. `scripts/` holds the tooling that processes the files. `index.html` plus `public/` are the built site, and the front end is written in Rust with the Leptos framework, compiled to WebAssembly and running in the browser with `csr` (client-side rendering) enabled.

That choice has a visible consequence in `Cargo.toml`. The release profile sets `opt-level = 'z'`, `lto = true`, `codegen-units = 1` and `panic = "abort"`. Those are size-oriented settings, not speed-oriented ones. For a page that loads a few hundred deadline records, shipping a small `.wasm` file matters more than raw compute, and the manifest reads as a deliberate trade in that direction.

The dependencies also show where the data comes from at runtime. `gloo-net` with the `http` and `json` features handles requests, `serde` and `serde_json` are dependencies, and `chrono` handles dates. The `web-sys` features include `Window`, `Navigator` and `Storage`, which points at browser local storage as the place user preferences or cached data would live.

Timezone handling is the part worth understanding before you trust a date. Each conference entry carries a `timezone` field, and the README says it currently supports `UTC-12` through `UTC+12`, plus `AoE` and `PT`. The `PT` option is described as US Pacific Time that auto-adjusts for daylight saving. That is a real distinction: a fixed `UTC-8` offset and `PT` produce different instants in summer, and the README treats them as separate values.

Installing the Python CLI and checking one real deadline

The README points to the CLI under `extensions/cli` in the repository, described there as the PyCli Tool. The README's extensions table links to that folder without a package name or install command, so the reliable route is to clone the repository and work from that directory rather than to guess a package name.

Get the source first:

bash
git clone https://github.com/ccfddl/ccf-deadlines.git
cd ccf-deadlines/extensions/cli

From there, inspect the directory contents before running anything. The extensions table does not show the CLI's entry point, flags or output format, so the invocation has to come from the files in that folder.

If you would rather not install anything, the same data is available through the iCal subscription under `extensions/ical`, the Raycast extension, the SwiftBar plugin, the Chrome extension and the separate TUI app at `github.com/ccfddl/tui`. The README lists two web portals: the main site at `ccfddl.com` and a tabular portal at `ccfddl.top`, which the README describes as requiring no ladder.

To contribute a correction, the README gives a three-step path. Fork the repository, then add or update the file at `conference/conf_type/conf_name.yml`, then send a pull request. The README's example entry is `conference/DB/sigmod.yml`, and the field table marks `title`, `description`, `sub`, `rank`, `dblp`, `year`, `id`, `link`, `timeline`, `timezone`, `date` and `place` as required. Within `timeline`, `deadline` is required and must be either `yyyy-mm-dd hh:mm:ss` or the literal `TBD`; `abstract_deadline` and `comment` are optional.

A minimal entry following that schema looks like this:

yaml
- title: SIGMOD
  description: ACM Conference on Management of Data
  sub: DB
  rank:
    ccf: A
  dblp: sigmod
  confs:
    - year: 2022
      id: sigmod22
      link: http://2022.sigmod.org/
      timeline:
        - deadline: '2021-07-02 17:00:00'
          comment: 'first round'
      timezone: UTC-8
      date: June 12-17, 2022
      place: Philadelphia, PA, USA

The `sub` value is not free text. The field table defines `sub` as the category the conference is labelled by CCF and points to a matching table, so a new file has to use an existing code or the entry will not slot into the category structure.

Where ccf-deadlines breaks down

The first limitation is structural, not technical: nothing in the repository guarantees that a deadline is current. A conference file is only as accurate as its last merged pull request. If a programme committee extends a deadline, the YAML keeps the old instant until someone notices and opens a PR. You are trusting a volunteer.

The second is the notification model. The extensions listed in the README are pull-style: a CLI you run, a menu bar plugin that polls, a browser extension, an iCal subscription, a WeChat applet.

The third is coverage. The dataset is organised around CCF categories and the README's matching table is explicitly a CCF-derived taxonomy. A workshop, a journal special issue, or a conference outside the CCF lists has no obvious home here, and the `rank` block expects a `ccf` value. The `core` and `thcpl` fields are optional according to the field table, but `ccf` is marked required, which tells you what the project is built around.

The fourth is the timezone vocabulary. The README states support for `UTC-12` to `UTC+12`, plus `AoE` and `PT`. That is wide, but it is a fixed enumeration. A conference that publishes its deadline in a named zone outside that set, or in a zone with unusual offset rules, has to be approximated by the contributor, and the approximation is invisible to you as a reader.

How it differs from a general calendar or a wiki list

The closest alternative in everyday use is a shared Google Calendar or a manually maintained spreadsheet. Those are editable by anyone with access and require no pull request, which is faster for a small group. ccf-deadlines trades that speed for review: the YAML goes through a pull request, and the result is a public, versioned file with a git history. For a lab tracking twenty conferences, the spreadsheet is easier. For a public dataset that thousands of people read, the review step is the point.

A second alternative is a per-conference calendar feed published by the conference itself. That is authoritative by definition, and it is the right source when you care about exactly one venue. The difference in approach is scope: ccf-deadlines aggregates across venues and normalises timezones and ranks in one schema, which a single conference feed never does. The cost is that aggregation introduces a contributor between you and the source.

A third is a commercial conference-ranking product. Those typically bundle the ranking data with a subscription and a support commitment. ccf-deadlines is MIT-licensed and the data is in the repository, so you can read it, fork it, or build your own client against it. The difference is not features; it is who is accountable when an entry is wrong. Here, nobody is, and the README's answer to that is the pull request.

Licence, maintenance and what upgrading costs you

The repository is MIT licensed, and the LICENSE file sits at the root. For most users that means the code and the conference data can be reused, modified and redistributed, including in a closed product, provided the licence terms are met. This is not legal advice; if you plan to redistribute the dataset commercially, read the LICENSE file and the terms of any upstream ranking data the entries reference.

Maintenance cost is unusual for a software project because the primary artefact is data, not code. The Rust client changes rarely; the YAML files change constantly as deadlines are announced. The last push to the repository was on 2026-11-02, and the repository is not archived, so the dataset is being edited. That tells you the data pipeline is alive. It does not tell you that any particular conference file is current.

Upgrading is therefore not a versioned operation. The repository has no published GitHub releases, so there is no changelog to read and no migration path to follow. If you consume the data, you re-read it. If you fork the client, you track `main` and rebuild the WebAssembly bundle yourself, which means installing a Rust toolchain and the `wasm-bindgen` tooling implied by `Cargo.toml`. Budget time for that if you intend to self-host the site.

The practical cost of adopting ccf-deadlines is the cost of checking. You are not paying for a service; you are taking on the job of confirming that the entries you care about were updated for the current cycle.

Editorial conclusion

Adopt ccf-deadlines if you want a single timezone-normalised deadline list you can subscribe to or query from a terminal, and if you are willing to send a pull request when an entry is wrong. Do not adopt it if you need guaranteed notification delivery or a supported commercial data feed; the repository is a community dataset with no published GitHub releases. Before relying on it, open the yml file for your target conference, confirm the deadline string and the timezone field, and check whether the entry was updated for the current cycle.

Frequently asked questions

What are the deadlines for AI conferences in 2026?

The project does not publish a single AI deadline list; deadlines live in per-conference YAML files under `conference/`, and each entry carries a `year` field so you can filter for the cycle you care about. The README does not state how many AI entries exist or when they were last updated, so open the relevant yml file and check its `timeline` block.

Is ICML CCF A?

The repository stores CCF ranks in the `rank.ccf` field of each conference YAML file, so the answer is whatever that file says. Open ICML's YAML file and read its `rank.ccf` value.

Can ccf-deadlines provide a list of major computer science conferences?

Yes, in the sense that the repository is organised as a directory of conference YAML files grouped by CCF subject area, with each entry's `sub` field naming its CCF category. The README does not state the total number of conferences covered, so treat the directory listing as the authoritative count.

Official sources

  1. ccfddl/ccf-deadlines on GitHub
  2. Issues
  3. License: MIT
  4. Project website
  5. README
Add this badge to your README

If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.

Add this badge to your README

markdown
[![Hysen Labs](https://hysenlabs.com/badge/ccfddl-ccf-deadlines.svg)](https://hysenlabs.com/projects/ccfddl-ccf-deadlines)

Star history chart for your README

markdown
[![Star history](https://hysenlabs.com/chart/ccfddl-ccf-deadlines.svg)](https://hysenlabs.com/projects/ccfddl-ccf-deadlines)

Was this useful?