KCL is an open-source configuration and policy language hosted by the Cloud Native Computing Foundation (CNCF) as a Sandbox Project. Built on a foundation of constraints and functional programming principles, KCL enhances the process of writing complex configurations, particularly in cloud-native environments. By leveraging advanced programming language techniques, KCL promotes improved modularity, scalability, and stability in configuration management. It simplifies logic writing, offers easy-to-use automation APIs, and seamlessly integrates with existing systems.

This section will update the KCL language community's latest news, including features, website updates, and the latest community news, helping everyone better understand the KCL community!

KCL Website: https://kcl-lang.io

Special Thanks​

Special thanks to all community contributors over the past two weeks. The following list is in no particular order:

• Thanks to @Vishalk91-4 for contributing to the KCL tree-sitter. 🙌
• Thanks to @liangyuanpeng for contributing to the KCL third-party modules kind and kubeadm. 🙌
• Thanks to @DavidChevallier for contributing to the KCL third-party libraries cilium and others. 🙌
• Thanks to @liangyuanpeng for contributing to the KCL CLI project. 🙌
• Thanks to @eshepelyuk, @haarchri, @liangyuanpeng, @logo749, @bilalba, @borgius, @patrick-hermann-sva, @ovk, @east4ming, @wmcnamee-coreweave, @steeling, @sschne, @Jacob Colvin, @Richard Holmes, @Christopher Haar, @Yvan da Silva, @Uladzislau Maher, @Sergey Ryabin, @Lukáš Kubín, @Alexander Fuchs, @Divyansh Choukse and others for their invaluable suggestions and feedback during the recent period of using KCL 🙌

Overview​

Thanks to all contributors for their outstanding work over the past two weeks. Here is an overview of the key content:

📦️ Modules Updates

• Add new third-party library kind that supports creating and managing clusters.
• Third party library kubeadm updated some fields.
• Third party library external-secrets updated to version 0.1.1.
• Third party library cilium updated to version 0.1.2, removing the duplicate declaration of regex.match.
• Konfig updated the example of adding more resource models.
• Konfig updated the example of adding additional pod metadata annotations.

🏄 Language Updates

• Assignment statements support attribute access and index access for the assigned target.
• Fixed KCL nested multi-level config block semantic check costing too long time.
• Removed the unwrap() in the semantic resolver to reduce panic issues.
• Fixed the error merge of the list index field by merge operation.

💻 IDE Updates

• Fixed the error completion of schema doc in the IDE.
• Fixed the issue of attributes defined in the unification not being automatically completed.
• KCL vim plugin update installation documentation.
• KCL vscode plugin removed the response to yaml files.
• KCL vscode plugin added Apache 2.0 License.

📬️ Toolchain Updates

• Package management tool fixed the issue of the compilation entry not recognizing the package relative path ${KCL_MOD}.
• Package management tool changed the PlainHttp option to optional.
• Package management tool fixed the compilation failure caused by the virtual compilation entry.
• Package management tool fixed the issue of the default dependency missing in kcl.mod.
• Package management tool fixed the vendor path calculation error that caused third-party dependencies to be re-downloaded.
• Package management tool fixed the push https protocol OCI registry failure.
• Package management tool added a cache for login credentials to reduce security risks.
• Package management tool fixed the compilation entry error of the root directory.
• KCL tree-sitter added sequence operations and selector support.

⛵️ API Updates

• Refactored the error message of the override_file API.

🔥 SDK Updates

• Added KCL C/C++ language SDK.
• Added Go, Java, Python, Rust, .NET, C/C++, and other multi-language API Specs, related documents, test cases, and examples.
• Refactored the go code structure, moving go-related code to the go file directory.

📚️ Documentation Updates

• Added Python, Java, Node.js, Rust, Wasm, .NET, C/C++ and other multi-language API documents.
• Updated the IDE Quick Start document.
• Added New Blog A Comparative Overview of Jsonnet and KCL.
• Updated the crd in Adapt From Kubernetes.

Resources​

❤️ See here to join us!

For more resources, please refer to

• KCL Website
• KusionStack Website

What is Jsonnet​

Jsonnet is a Domain Specific Language (DSL) designed to simplify the creation, management, and maintenance of JSON data. It was originally designed and developed by Google employee Dave Cunningham as a 20% project around 10 years ago. The design of Jsonnet was influenced by several configuration languages used internally at Google, with the aim of improving the readability, maintainability, and programmability of configuration files while remaining compatible with JSON. It introduces features such as variables, functions, conditionals, loops, and code comments, making it easier and more intuitive to write complex data structures.

Jsonnet code is currently owned by Google. However, last month, due to the departure of Jsonnet's founder Dave Cunningham from Google for a new venture, the project is now managed by Rohit Jangid within Google.

What is KCL​

KCL is an open-source, constraint-based record and functional language that enhances the writing of complex configurations, including those for cloud-native scenarios. It is hosted by the Cloud Native Computing Foundation (CNCF) as a Sandbox Project. With advanced programming language technology and practices, KCL is dedicated to promoting better modularity, scalability, and stability for configurations. It enables simpler logic writing and offers ease of automation APIs and integration with homegrown systems.

Differences Between Jsonnet and KCL​

Design Philosophy​

Jsonnet aims to enhance the readability and conciseness of configuration files through the introduction of programming language features such as variables, functions, operators, and control structures. This approach lowers the management complexity of complex configurations with guaranteed full compatibility with JSON. However, Jsonnet does not address important features such as types and validation, leading to a lack of consideration for stability and engineering efficiency in the configuration and policy domain.

At a design level, KCL is more "universal" and "modern", not only in its language design elements but also in its specific language features. Additionally, KCL focuses not only on simplifying the creation, management, and maintenance of JSON/YAML data, but also addresses specific cloud-native complexities and security risks. It converges language design towards problems specific to the cloud-native domain, aiming to converge its design around language technology and GitOps integration to strengthen stability and consistency guarantees. It achieves this through automated API, strong immutability, conflict detection, and support for custom validation expressions, among other capabilities.

Language Features​

Both KCL and Jsonnet support variable definition, references, function definitions, and configuration merging, although their degrees of support and syntax semantics differ. They both support common programming language features such as arithmetic, logical operations, comprehensions, conditions, functions, standard libraries, and importing third-party modules, although in different manners. Unlike Jsonnet, KCL provides support for user-defined types, limited or mixed support for object-oriented features, and immutability, ensuring stability at an engineering level. Both KCL and Jsonnet can directly import JSON/YAML data types and Kubernetes CRDs.

Moreover, KCL integrates many built-in language features to fulfill configuration scenarios, such as configuration patching, data validation, and security compliance. This provides KCL with more static analysis capabilities to meet IDE or other tool chain needs and combine constraint checking.

Developer Tools​

Both Jsonnet and KCL communities provide a wide range of language tools, including testing, formatting, and package management support. While Jsonnet's dynamic nature makes comprehensive IDE support difficult, KCL offers official Language Server support, which can be easily extended and integrated into IDE plugins, including NeoVim and other emerging LSP-supported IDEs or editors. KCL's Language Server provides complete features such as syntax highlighting, autocompletion, navigation, refactoring, and quick fixes, and is growing rapidly.

Multiple Language Bindings​

For better integration of configuration language into users' applications, Jsonnet currently provides four different multi-language implementations in the community, including C++, Go, Rust, and Python bindings. KCL currently offers an official Rust implementation and provides various bindings such as Go, Python, Java, Node.js, C#, C++, C, and WASM, all based on Rust, ensuring predictable and consistent results regardless of the language used.

Performance​

• KCL (test.k)

a = lambda name: str {
    apiVersion = "apps/v1"
    kind = "Deployment"
    metadata = {
        name = name
        labels = {"app": "nginx"}
    }
    spec = {
        replicas = 3
        selector.matchLabels = {"app": "nginx"}
        template.metadata.labels = {"app": "nginx"}
        template.spec.containers = [
            {
                name = metadata.name
                image = "${metadata.name}:1.14.2"
                ports = [{ containerPort = 80 }]
            }
        ]
    }
}
temp = {"a${i}": a("nginx") for i in range(1000)}

• Jsonnet (test.jsonnet)

local a(name) = {
    apiVersion: "apps/v1",
    kind: "Deployment",
    metadata: {
        name: name,
        labels: {["app"]: "nginx"}
    },
    spec: {
        replicas: 3,
        selector: {
            matchLabels: {["app"]: "nginx"}
        },
        template: {
            metadata: {
                labels: {["app"]: "nginx"}
            },
            spec: {
                containers: [
                    {
                        name: name,
                        image: name + ":1.14.2",
                        ports: [{ containerPort: 80 }]
                    }
                ]
            }
        },
    }
};
{
    temp: {["a%d" % i]: a("nginx") for i in std.range(0, 1000)},
}

Run time (considering actual resource expenditure in production environments, this test is based on a single core):

Summary​

The comparison table below summarizes the features of Jsonnet and KCL for reference.

References​

• KCL Website: https://kcl-lang.io/
• KCL GitHub Repository: https://github.com/kcl-lang/kcl
• Jsonnet Website: https://jsonnet.org/
• Jsonnet C++ Version GitHub Repository: https://github.com/google/jsonnet
• Jsonnet Go Version GitHub Repository: https://github.com/google/go-jsonnet
• Jsonnet Rust Version (jrsonnet) GitHub Repository: https://github.com/CertainLach/jrsonnet
• Jsonnet Rust Version (rsjsonnet) GitHub Repository https://github.com/eduardosm/rsjsonnet