awesome-repositories.com
Blog
awesome-repositories.com

Discover the best open-source repositories with AI-powered search.

ExploreCurated searchesOpen-source alternativesSelf-hosted softwareBlogSitemap
ProjectAboutHow we rankPressMCP server
LegalPrivacyTerms
© 2026 Bringes Technology SRL·VAT RO45896025·hello@awesome-repositories.com
·
Kotlin avatar

Kotlin/KEEP

0
View on GitHub↗
3,735 stars·384 forks·Markdown·Apache-2.0·3 viewskotlinlang.org/docs/kotlin-language-features-and-proposals.html↗

KEEP

KEEP is a language evolution tracker and governance tool for the Kotlin programming language. It serves as a centralized portal for managing the lifecycle of language enhancement proposals and tracking the progression of syntax and semantic changes from initial design to final release.

The project functions as a technical proposal workflow engine to coordinate the review, acceptance, and revocation of formal design requests. It provides a system for documenting early ideas, integrating community feedback, and managing the evolution of language features.

The platform also handles programming language governance by documenting API stability levels and managing version compatibility markers for language components. This ensures that the maturity of features is communicated and that breaking changes are managed through a structured design process.

Features

  • Language Evolution - Tracks the entire lifecycle of language features from initial design to final release.
  • Proposal Lifecycles - Manages the evolution of language features through a state-based proposal lifecycle and committee consensus.
  • Design - Provides a system to store preliminary design notes and explore syntax options before drafting formal proposals.
  • Syntax Design - Documents and iterates on new syntax and semantic proposals to increase language expressiveness.
  • API Stability Markers - Assigns API stability markers to designate the release stage and maturity level of language components.
  • Feature Evolution Tracking - Tracks the progression of language features from initial design and community feedback through to stable release.
  • Language Design Processes - Provides formal methods and community-driven processes for proposing and refining language features.
  • Language Governance Portals - Provides a centralized repository for documenting stability levels and version compatibility for language components.
  • Language Governance Tools - Provides a platform for managing API stability levels and version compatibility markers.
  • Language Proposal Tracking - Provides a system for documenting design discussions and tracking the evolution of language proposals.
  • Compiler Version Enforcers - Enforces specific version requirements to ensure consistent behavior and compatibility across different releases.
  • Language Feature Feedback - Links external issue trackers and forums to gather real-world usage patterns and user opinions on proposed language changes.
  • Community Feedback Channels - Integrates community feedback from external forums to inform the development of language features.
  • Proposal Lifecycle Management - Provides a framework for tracking the end-to-end evolution of technical design proposals from drafting to implementation.
  • Proposal Submission Workflows - Coordinates the review, acceptance, and revocation of formal design requests for language evolution.
  • Version-Gated Compilation - Implements version-gated compilation to restrict specific syntax and APIs to designated releases.
  • Stability Maturity Levels - Uses classification systems to define longevity and backward compatibility guarantees for software interfaces.
  • Build and Development Tools - Extends build and development tools by connecting debuggers and language servers with package managers.
  • Incremental Build Engines - Uses incremental build engines to track changes and execute only necessary compilation steps.
  • Cross-Platform Application Development - Enables the development of applications that run across multiple target operating systems and environments.
  • Multi-Target Compilers - Provides a multi-target compiler capable of transforming source code into various platform-specific formats.
  • Standard Libraries - Maintains a core set of stable APIs for essential tasks like collection management and I/O.
  • Cross-Platform Logic Sharing - Provides architectural strategies for sharing business logic across multiple native operating systems.
  • Build Performance Optimization - Implements incremental build resolution to decrease compilation time and optimize dependency resolution.
  • Cross-Platform Development - Supports a workflow for developing a single codebase targeting Android, iOS, Web, and desktop.
  • Language Guides - Official repository for Kotlin language evolution proposals.

Star history

Star history chart for kotlin/keepStar history chart for kotlin/keep

AI search

Explore more awesome repositories

Describe what you need in plain English — the AI ranks thousands of curated open-source projects by relevance.

Start searching with AI

Open-source alternatives to KEEP

Similar open-source projects, ranked by how many features they share with KEEP.
  • haxefoundation/haxeHaxeFoundation avatar

    HaxeFoundation/haxe

    6,880View on GitHub↗

    Haxe is a statically typed, multi-target programming language and open-source compiler toolkit that translates a single codebase into native executables and scripts for JavaScript, C++, C#, Java, Python, Lua, PHP, and Flash targets. It provides a unified type system with automatic type inference, a compile-time macro system for code transformation and generation, conditional compilation directives, and a static analysis engine that enforces null safety and eliminates dead code to produce smaller, safer outputs. The language is supported by the HashLink virtual machine, which executes platform

    Haxecompilercross-platformhaxe
    View on GitHub↗6,880
  • tc39/ecma262tc39 avatar

    tc39/ecma262

    15,653View on GitHub↗

    The ECMAScript specification is the formal standard defining the syntax, semantics, and execution model that all JavaScript implementations must follow. It establishes the official language rules through a combination of formal grammar and step-by-step algorithmic prose. The project manages the technical evolution of the language via a consensus-driven governance framework and a staged proposal pipeline. This process tracks features from initial design through expert reviewer sign-off and committee approval. A specification-as-code toolchain compiles these formal definitions and algorithmic d

    HTMLecmascriptjavascript
    View on GitHub↗15,653
  • reactjs/rfcsreactjs avatar

    reactjs/rfcs

    5,792View on GitHub↗

    This repository is a technical proposal collection and open source governance workflow used to manage the lifecycle of feature requests. It functions as a collaborative API design framework where major architectural changes are proposed and tracked from initial draft to final acceptance. The project utilizes a Git-based governance workflow to gather community consensus. It leverages version control, pull requests, and Markdown documents to facilitate asynchronous technical reviews and distributed contributor agreement. The system covers the coordination of technical consensus and the managem

    View on GitHub↗5,792
  • vuejs/rfcsvuejs avatar

    vuejs/rfcs

    4,938View on GitHub↗

    This repository serves as the official proposal archive and community governance framework for the Vue.js core framework. It functions as a technical design document store where substantial changes and new features are proposed, debated, and documented through a structured request for comments process. The project implements a transparent governance model to reach consensus on major architectural decisions. This involves a formal change proposal process and a community feedback system designed to refine technical concepts before they are committed to the final implementation. The repository

    View on GitHub↗4,938
See all 30 alternatives to KEEP→

Frequently asked questions

What does kotlin/keep do?

KEEP is a language evolution tracker and governance tool for the Kotlin programming language. It serves as a centralized portal for managing the lifecycle of language enhancement proposals and tracking the progression of syntax and semantic changes from initial design to final release.

What are the main features of kotlin/keep?

The main features of kotlin/keep are: Language Evolution, Proposal Lifecycles, Design, Syntax Design, API Stability Markers, Feature Evolution Tracking, Language Design Processes, Language Governance Portals.

What are some open-source alternatives to kotlin/keep?

Open-source alternatives to kotlin/keep include: haxefoundation/haxe — Haxe is a statically typed, multi-target programming language and open-source compiler toolkit that translates a… tc39/ecma262 — The ECMAScript specification is the formal standard defining the syntax, semantics, and execution model that all… reactjs/rfcs — This repository is a technical proposal collection and open source governance workflow used to manage the lifecycle of… vuejs/rfcs — This repository serves as the official proposal archive and community governance framework for the Vue.js core… reasonml/reason — Reason is a strongly typed functional language and multi-target compiler designed to produce either JavaScript for web… android/kotlin-multiplatform-samples — This repository provides a collection of reference implementations for building mobile applications using the Kotlin…