CCF-Deadlines: A Researcher's Tool for Tracking Conference Submission Deadlines

The Problem: Tracking Deadlines Across Dozens of Venues

Academic researchers submitting to top computer science conferences track submission deadlines across a fragmented set of sources: individual conference websites, academic mailing lists, and community wikis. CCF-Deadlines consolidates this into a single interface indexed by venue rank and research area.

The project targets researchers in China and internationally who publish at conferences ranked by the Chinese Computer Federation (CCF). The CCF ranking divides conferences into three tiers: A (top), B, and C. Conferences in CCF-A categories like SIGMOD, ICML, and NeurIPS carry significant weight in Chinese academic evaluation systems. CCF-Deadlines also includes CORE and TH-CPL rankings, which are used in Australian and Chinese institutional contexts respectively.

Beyond the deadline itself, the project tracks abstract deadlines (which often fall one to two weeks before the paper deadline), rebuttal periods, and decision dates, all in a single entry. This is the main practical advantage over bookmarking individual conference sites: researchers can see the full review timeline for a venue, not just the submission cutoff.

A PhD student or faculty member monitoring ten to twenty venues simultaneously would otherwise maintain a spreadsheet or rely on memory. CCF-Deadlines surfaces deadlines sorted by proximity, so the most urgent submissions are always visible at the top. The web interface at ccfddl.github.io and the secondary site at ccfddl.top serve the same data and are the zero-configuration access points for researchers who do not want to run any local tooling.

The Conference Data Format

Each conference is stored in a YAML file under `conference/<sub>/<name>.yml`, where `<sub>` is one of ten research category codes: DS (computer architecture), NW (network systems), SC (security), SE (software engineering), DB (database and data mining), CT (computing theory), CG (graphics), AI (artificial intelligence), HI (human-computer interaction), and MX (interdisciplinary).

A conference entry uses this structure:

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

The timeline array can hold multiple rounds, each with optional `abstract_deadline`, `rebuttal_deadline`, and `decision_deadline` fields alongside the main deadline. The timezone field accepts UTC offsets from UTC-12 to UTC+12, plus `AoE` (Anywhere on Earth) and `PT` (US Pacific Time, with automatic daylight saving adjustment). Fields marked with an asterisk in the README are required; optional fields include abstract deadline, rebuttal and decision dates, and the CORE and TH-CPL rankings.

The Web Interface and Access Points

The primary interface is the website at ccfddl.github.io. A second site at ccfddl.top is also available; the README notes it does not require a ladder, which is a reference to accessibility from mainland China where the github.io domain can be unreliable. Both sites render the same data.

The frontend is built with Leptos, a Rust web framework that compiles to WebAssembly. The Cargo.toml shows Leptos 0.8.8 as the main dependency, alongside chrono for date handling, gloo-net for HTTP, and thaw for UI components. The site is served as a client-side-rendered WASM application.

Extensions and integrations extend the reach beyond the web: a Python CLI in the `extensions/cli/` directory, a Raycast extension for macOS, a SwiftBar plugin for the macOS menu bar, an iCal subscription for calendar integration, a Chrome extension, and a terminal UI (TUI) application. Each extension is maintained separately in the repository tree.

The iCal subscription is particularly useful for researchers who want deadlines to appear in their calendar application alongside meetings and travel. Once configured, deadline updates from the repository appear automatically without visiting the website. The Chrome extension provides a browser-level indicator, giving deadline visibility without opening a separate tab.

Contributing a Conference Entry

New conference entries go in as pull requests. The contribution workflow the README describes:

git clone https://github.com/ccfddl/ccf-deadlines.git

Then add or update the YAML file for the conference under `conference/<sub>/<name>.yml` and submit a pull request. The README points to the official CCF recommended conference list as a reference for the `sub` and `rank.ccf` fields.

A `.pre-commit-config.yaml` file is present in the repository, suggesting pre-commit hooks are used for validation. The `requirements.txt` includes `jsonschema` and `icalendar` alongside the CLI requirements, indicating that schema validation of the YAML files and iCal export run as part of the tooling.

The accuracy of the data depends entirely on contributors updating YAML files for each new conference cycle. When a conference announces its 2027 dates and deadlines, someone must fork the repository, update the YAML, and submit a pull request before those deadlines appear on the site.

Limitations and When to Use Something Else

CCF-Deadlines covers conferences on the CCF recommended list and those added by contributors. Workshops, symposia, and venues outside the CCF system are generally absent unless someone specifically added them. A researcher whose primary target venues are IEEE and ACM conferences without CCF rankings will find the coverage incomplete.

The YAML data model captures deadlines but not page limits, formatting requirements, review criteria, acceptance rates, or other submission context. Users must still visit the individual conference site for those details.

The Python CLI requires its own installation from the requirements in `extensions/cli/req.txt`, separate from the website. The website itself is static and does not require any local setup.

For researchers outside the CCF system, a common alternative is WikiCFP, a web-based call-for-papers tracker that aggregates conferences and workshops globally. WikiCFP covers a wider range of venues but does not provide CCF, CORE, or TH-CPL ranking information alongside the deadlines. The practical choice between them depends on whether the ranking context is needed.

Conferences with rolling submissions or workshops with informal deadlines are also outside the scope. The project models deadline data as discrete YAML entries per year, so continuous submission models do not fit neatly into the data format. Researchers who primarily target journals or preprint-first venues will get less value from a conference deadline tracker by design.

Licensing and Repository Activity

CCF-Deadlines is licensed under the MIT licence, which permits use, modification, and redistribution with no restrictions beyond attribution. The repository has no GitHub releases, so the current state of the codebase is what is in the main branch. The last push was on 2026-09-27, indicating active community maintenance.

The `Cargo.lock` file is committed, which is consistent with the repository being a binary application (the Leptos site) rather than a library. For contributors working on the Rust frontend, this provides reproducible builds. Contributors adding conference YAML files do not interact with the Rust build at all.

The `.pre-commit-config.yaml` and `.agents/` directories in the top level suggest the project has automated validation and agent-assisted workflows in place. The `accept_rates/` directory at the root stores acceptance rate data for tracked conferences, giving researchers a quick reference for venue competitiveness alongside the deadline information.

Editorial conclusion

CCF-Deadlines is useful for any computer science researcher who needs to track multiple conference deadlines across different areas and ranking systems. The web interface at ccfddl.github.io is the lowest-friction entry point. Researchers outside the CCF system can filter by CORE or TH-CPL rankings instead. The project's YAML-based contribution model means coverage depends entirely on the community submitting pull requests. The repository had its last push on 2026-09-27.

Frequently asked questions

Official sources

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