Skip to main content

8 posts tagged with "Release Blog"

View All Tags

· 9 min read

Introduction​

The KCL team is pleased to announce that KCL v0.9.0 is now available! This release has brought three key updates to everyone

  • Enhance the coding experience and efficiency with a more performant, feature-rich, and less error-prone KCL language, toolchain, and IDE.
  • A more comprehensive and diverse set of standard libraries, third-party libraries, and community ecosystem integrations, covering different application scenarios and requirements.
  • Richer multi-language SDKs and plugins, seamlessly integrating with different programming languages and development environments.

KCL is an open-source, constraint-based record and functional language hosted by Cloud Native Computing Foundation (CNCF). KCL improves the writing of numerous complex configurations, such as cloud-native scenarios, through its mature programming language technology and practice. It is dedicated to building better modularity, scalability, and stability around configurations, simpler logic writing, faster automation, and great built-in or API-driven integrations.

❤️ Special Thanks​

We would like to extend our heartfelt thanks to all 120 community contributors who participated in the iteration from version v0.8 to v0.9 over the past 120 days. The following list is in no particular order.

@Shashank Mittal, @MattHodge, @officialasishkumar, @Gmin2, @Akash Kumar, @sfshumaker, @sanzoghenzo, @MOHAMED FAWAS, @bradkwadsworth-mw, @excalq, @Daksh-10, @metacoma, @Wes McNamee, @Stéphane Este-Gracias, @octonawish-akcodes, @zong-zhe, @shashank-iitbhu, @NAVRockClimber, @AkashKumar7902, @Petrosz007, @patrycju, @Korada Vishal, @selfuryon, @tvandinther, @vtomilov, @Peefy, @taylormonacelli, @Tertium, @Stefano Borrelli, @Bishal, @kukacz, @borgius, @steeling, @jheyduk, @HStéphane Este-Gracias, @userxiaosi, @folliehiyuki, @kubernegit, @nizq, @Alexander Fuchs, @ihor-hrytskiv, @Mohamed Asif, @reedjosh, @Wck-iipi, @evensolberg, @aldoborrero@ron18219, @rodrigoalvamat, @mproffitt, @karlhepler, @shruti2522, @leon-andria, @prahaladramji, @Even Solberg, @utnim2, @warjiang, @Asish Kumar, @He1pa, @Emmanuel Alap, @d4v1d03, @Yvan da Silva, @Abhishek, @DavidChevallier, @zargor, @Kim Sondrup, @SamirMarin, @Hai Wu, @MatisseB, @beholdenkey, @nestoralonso, @HAkash Kumar, @olinux, @liangyuanpeng, @ngergs, @Penguin, @ealap, @markphillips100, @Henri Williams, @eshepelyuk, @CC007, @mintu, @M Slane, @zhuxw, @atelsier, @aleeriz, @LinYunling, @YvanDaSilva, @chai2010, @Sergey Ryabin, @vfarcic, @vemoo, @riven-blade, @ibishal, @empath-nirvana, @bozaro, @jgascon-nx, @reckless-huang, @Sergei Iakovlev, @Blarc, @JeevaRamanathan, @dennybaa, @PrettySolution, @east4ming, @nkabir, @sestegra, @XiaoK29, @ricochet1k, @yjsnly, @umaher, @SjuulJanssen, @wilsonwang371, @Lukáš Kubín, @samuel-deal-tisseo, @blakebarnett, @Uladzislau Maher, @ytsarev, @Vishalk91-4, @Stephen C, @Tom van Dinther, @MrGuoRanDuo, @dopesickjam

📚 Key Updates​

⚡️ Performance Enhancements​

Runtime Performance​

In the new KCL v0.9 release, a new fast runtime mode has been introduced. This can be enabled by setting the KCL_FAST_EVAL=1 environment variable, which improves startup and runtime performance. For configurations using Schema (such as the k8s third-party library), this offers approximately a 3x performance boost compared to previous versions. For simple configurations without Schema, output YAML performance has been tested to surpass tools like helm template and kustomize build that use YAML and Go Templates.

IDE Performance​

KCL IDE has further optimized incremental compilation and performance for semantic analysis in large projects. For KCL projects with around 400 files, the end-to-end response time has been reduced to 20% of the previous version.

🔧 Core Features​

Language​

  • String interpolation now supports escaping with \${} similar to Shell to cancel interpolation.
world = "world"
hello_world_0 = "hello ${world}"  # hello world
hello_world_1 = "hello \${world}" # hello ${world}
  • Added schema type support to the typeof function for distinguishing schema types from instances.
schema Foo:
    bar?: str

foo = Foo {}
type_schema = typeof(foo) # schema
type_type = typeof(Foo) # type
  • Added a full_pkg keyword argument to the instances() method of Schema to read instances of the corresponding schema from all code.
schema Person:
    name: str

alice = Person {name = "Alice"}
all_persons = Person.instances(True)
  • Removed implicit comparison between bool and int types 0 < True.
  • Removed comparison features for the list type [0] < [1].
  • Added type assertion failure functionality to the as keyword.
  • Optimized closure variable capture logic of lambda functions and configuration code blocks {} in different scopes to be more intuitive.

Toolchain​

  • kcl run now supports outputting configurations in TOML format with the --format toml option.
  • kcl mod add now supports adding dependencies from private third-party OCI Registries and Git repositories with the --oci and --git options.
  • kcl import now supports importing entire Go Packages as KCL Schemas.
  • kcl import now supports importing files with YAML stream format (---).
  • kcl import now supports importing TOML files as KCL configurations.
  • kcl clean now supports cleaning external dependencies and compile caches.
  • kcl mod init now supports setting the version of a new KCL module with the --version tag.
  • Commands like kcl run, kcl mod add, and kcl mod pull now support accessing private repositories via local Git.

IDE​

  • Supports multiple quick fix options.
  • Syntax highlighting for kcl.mod and kcl.mod.lock files.
  • Partial syntax hover highlighting in the IDE.
  • import completion for external dependencies.
  • Function symbol highlighting and Inlay Hints displaying default variable types.

inlayhint

API​

  • The Override API now supports setting different attribute operators (:, =, and +=) for configuration overrides.
  • Go API now supports prototext format and KCL schema output as KCL configurations.
  • Go API now supports serializing any Go Type and Go Value to KCL Schema and configurations.

📦️ Standard Libraries and Third-Party Libraries​

Standard Libraries​

  • Added the file standard library for file IO operations, such as reading configurations from YAML and performing configuration merges.
import file
import yaml
import json_merge_patch as p

config = p.merge(yaml.decode(file.read("deployment.yaml")), {
    metadata.name = "override_value"
})

For more functions in the file module, see: https://www.kcl-lang.io/docs/reference/model/file

  • Added the template standard library for writing template configurations.
import template

_data = {
    name = "handlebars",
    v = [ { a = 1 }, { a = 2 } ],
    c = { d = 5 },
    g = { b = [ { aa = { bb = 55} }, { aa = { bb = 66} } ] },
    people = [ "Yehuda Katz", "Alan Johnson", "Charles Jolley" ]
}

content = template.execute("""\
Hello world from {{name}}

{{#each v}}
{{this.a}}
{{/each}}
{{ c.d }}
{{#each people}}
{{ this }}
{{/each}}
{{#each g.b}}
{{this.aa.bb}}
{{/each}}
""", _data)
  • Added the runtime standard library for capturing runtime exceptions, useful for kcl test tool to test exception cases.
import runtime

schema Person:
    name: str
    age: int

    check:
        0 <= age <= 120, "age must be in [1, 120], got ${age}"

test_person_check_error = lambda {
    assert runtime.catch(lambda {
        p = Person {name = "Alice", age: -1}
    }) == "age must be in [1, 120], got -1"
}

Third-Party Libraries​

The number of KCL models has increased to 313, including major updates as follows:

  • k8s released version 1.30
  • argo-cd released version 0.1.1
  • argo-workflow released version 0.0.3
  • istio released version 1.21.2
  • victoria-metrics-operator released version 0.45.1
  • cert-manager released version 0.1.2
  • cilium released version 0.1.1
  • Longhorn released version 0.0.1
  • jsonpatch released version 0.0.5, supporting rfc6901Decode
  • Added a new third-party library difflib for comparing configuration differences
  • Added argo-cd-order for sorting argocd sync operation resource order
  • Added models for cluster-api, including cluster-api, cluster-api-provider-metal3, cluster-api-provider-gcp, cluster-api-addon-provider-helm, cluster-api-addon-provider-aws, cluster-api-provider-azure, and more

☸️ Ecosystem Integration​

apiVersion: apiextensions.crossplane.io/v1
kind: Composition
metadata:
  name: example
spec:
  compositeTypeRef:
    apiVersion: example.crossplane.io/v1beta1
    kind: XR
  mode: Pipeline
  pipeline:
    - step: basic
      functionRef:
        name: function-kcl
      input:
        apiVersion: krm.kcl.dev/v1alpha1
        kind: KCLInput
        source: |
          # Read the XR
          oxr = option("params").oxr
          # Patch the XR with the status field
          dxr = oxr | {
              status.dummy = "cool-status"
          }
          # Construct a AWS bucket
          bucket = {
              apiVersion = "s3.aws.upbound.io/v1beta1"
              kind = "Bucket"
              metadata.annotations: {
                  "krm.kcl.dev/composition-resource-name" = "bucket"
              }
              spec.forProvider.region = option("oxr").spec.region
          }
          # Return the bucket and patched XR
          items = [bucket, dxr]
    - step: automatically-detect-ready-composed-resources
      functionRef:
        name: function-auto-ready

Additionally, you can find more real use cases of KCL with other ecosystem projects here:

🧩 Multi-Language SDKs and Plugins​

Multi-Language SDKs​

The number of KCL multi-language SDKs has increased to 7, currently supporting Rust, Go, Java, .NET, Python, Node.js, and WASM. These can be used without installing additional KCL command-line tools, optimizing the installation size to 90% of previous versions and removing the need for complex system dependencies. Furthermore, each SDK provides the same APIs for code execution, code analysis, type parsing, and adding external dependencies. Here are some examples with the Java and C# SDKs:

  • Java
import com.kcl.api.API;
import com.kcl.api.Spec.ExecProgram_Args;
import com.kcl.api.Spec.ExecProgram_Result;

public class ExecProgramTest {
    public static void main(String[] args) throws Exception {
        API api = new API();
        ExecProgram_Result result = api
                .execProgram(ExecProgram_Args.newBuilder().addKFilenameList("path/to/kcl.k").build());
        System.out.println(result.getYamlResult());
    }
}
  • C#
namespace KclLib.Tests;

using KclLib.API;

public class KclLibAPITest
{
    public static void Main()
    {
        var execArgs = new ExecProgram_Args();
        execArgs.KFilenameList.Add("path/to/kcl.k");
        var result = new API().ExecProgram(execArgs);
        Console.WriteLine(result.YamlResult);
    }
}

For more information on installing and using other SDKs, see https://github.com/kcl-lang/lib

Multi-Language Plugins​

The number of KCL multi-language plugins has increased to 3, currently supporting Go, Python, and Java. Only basic SDK dependencies are required to achieve seamless interoperation between common languages and KCL. Here are some examples with Python and Java plugins:

Write the following KCL code (main.k)

import kcl_plugin.my_plugin

result = my_plugin.add(1, 1)

Use the Python SDK to register a Python function for calling in KCL

import kcl_lib.plugin as plugin
import kcl_lib.api as api

plugin.register_plugin("my_plugin", {"add": lambda x, y: x + y})

def main():
    result = api.API().exec_program(
        api.ExecProgram_Args(k_filename_list=["main.k"])
    )
    assert result.yaml_result == "result: 2"

main()

Use the Java SDK to register a Java function for calling in KCL

package com.kcl;

import com.kcl.api.API;
import com.kcl.api.Spec.ExecProgram_Args;
import com.kcl.api.Spec.ExecProgram_Result;

import java.util.Collections;

public class PluginTest {
    public static void main(String[] mainArgs) throws Exception {
        API.registerPlugin("my_plugin", Collections.singletonMap("add", (args, kwArgs) -> {
            return (int) args[0] + (int) args[1];
        }));
        ExecProgram_Result result = new API()
                .execProgram(ExecProgram_Args.newBuilder().addKFilenameList("main.k").build());
        System.out.println(result.getYamlResult());
    }
}

For more examples of using other multi-language plugins, see https://www.kcl-lang.io/docs/reference/plugin/overview

Additionally, you can find more real use cases of KCL multi-language plugins here:

🌐 Other Resources​

🔥 Check out the KCL Community and join us 🔥

For more resources, refer to:

· 14 min read

Introduction​

The KCL team is pleased to announce that KCL v0.8.0 is now available! This release has brought three key updates to everyone: Language, Tools, and Integrations.

  • Use KCL language, tools and IDE extensions with more complete features and fewer errors to improve code writing experience and efficiency.

  • More comprehensive and rich community ecosystem integration, improving operation and maintenance experience.

  • More comprehensive KCL third-party dependencies, easier integration with cloud-native ecosystem.

KCL v0.8.0 is now available for download at KCL v0.8.0 Release Page or KCL Official Website.

KCL is an open-source, constraint-based record and functional language hosted by Cloud Native Computing Foundation (CNCF). KCL improves the writing of numerous complex configurations, such as cloud-native scenarios, through its mature programming language technology and practice. It is dedicated to building better modularity, scalability, and stability around configurations, simpler logic writing, faster automation, and great built-in or API-driven integrations.

This blog will introduce the content of KCL v0.8.0 and recent developments in the KCL community to readers.

Language Updates​

🚗 Grammar and Semantics Updates​

KCL supports show-hidden​

KCL v0.8.0 adds support for --show-hidden to display private variables.

The main.k

a = {_b = 1}

Compile by kcl run main.k --show-hidden.

a:
  _b: 1

KCL supports arguments and keyword arguments union​

KCL v0.8.0 adds support for arguments and keyword arguments union. Schema instances with arguments will union arguments during union operations.

schema Person[separator]:
    firstName: str = "John"
    lastName: str
    fullName: str = firstName + separator + lastName

x = Person(" ") {lastName = "Doe"}

y = Person("-") {lastName = "Doe1"}

z = x | y

The compiled result is as follows:

x:
  firstName: John
  lastName: Doe
  fullName: John Doe
y:
  firstName: John
  lastName: Doe1
  fullName: John-Doe1
z:
  firstName: John
  lastName: Doe1
  fullName: John-Doe1

KCL supports scalar yaml stream output​

In v0.8.0, by using yaml_stream method, you can output the result of yaml scalar.

import manifests

x0 = 1
x1 = 2
manifests.yaml_stream([x0, x1])

The compiled result is as follows:

1
---
2

KCL removes the __settings__ attribute in the compiled output​

In v0.8.0, the __settings__ attribute is removed from the compiled output.

schema Person:
    __settings__: {str:str} = {"output_type": "STANDALONE"}
    name?: str
    age?: int
    school?: str

a = Person{
    name: "a",
}

The compiled result is as follows.

a:
  name: a

KCL supports the key and value evaluation in the config expression​

In v0.8.0, KCL supports the key and value evaluation in the config expression.

_data = {
    "a": 'foo'
    "b": 'bar'
}

r0 = [{v = k} for k, v in _data]
r1 = [{k = v} for k, v in _data]
r2 = [{k.foo = v} for k, v in _data]
r3 = [[k] for k, v in _data]
r4 = [[k, v] for k, v in _data]

The compiled result is as follows.

r0:
  - foo: a
  - bar: b
r1:
  - a: foo
  - b: bar
r2:
  - a:
      foo: foo
  - b:
      foo: bar
r3:
  - - a
  - - b
r4:
  - - a
    - foo
  - - b
    - bar

🚀 Diagnostic Optimization​

KCL uses the elif keyword in the if block, not else if.

Compile the following KCL program:

if True: a = 1
else if False: b = 1

The diagnostic information in KCL has added suggestions for error correction:

error[E1001]: InvalidSyntax
 --> main.k:2:6
  |
2 | else if False: b = 1
  |      ^ 'else if' here is invalid in KCL, consider using the 'elif' keyword
  |

🚀 Language writing experience optimization​

KCL standard library adds file system access functions​

KCL has added methods to access the file system. In v0.8.0, it supports methods such as read, glob, etc. to access the file system.

By using the read, you can read the contents of a file as a string.

import file

a = file.read("hello.txt")

Add the following content to the hello.txt file:

Hello World !

The compilation result is as follows:

a: Hello World !

By combining the json.decode method, you can easily deserialize a JSON file.

Add the following content to the hello.json file:

{
  "name": "John",
  "age": 10
}

KCL program:

import file
import json

_a = json.decode(file.read("hello.json"))

name = _a.name
age = _a.age

The compilation result is as follows:

name: John
age: 10

More details - https://kcl-lang.io/zh-CN/docs/reference/model/file/

KCL Compiler supports the use of environment variable KCL_CACHE_PATH to specify the cache path​

KCL Compiler will cache the generated code to the directory specified by the environment variable KCL_CACHE_PATH. If not specified, it will be generated to the project root directory.

KCL Plugin System supports using Golang to write KCL plugins​

KCL Plugin System supports using Golang to write KCL plugins. The following is an example of using Golang to define the hello plugin.

package hello_plugin

import (
    "kcl-lang.io/kcl-go/pkg/plugin"
)

func init() {
    plugin.RegisterPlugin(plugin.Plugin{
        Name: "hello",
        MethodMap: map[string]plugin.MethodSpec{
            "add": {
                Body: func(args *plugin.MethodArgs) (*plugin.MethodResult, error) {
                    v := args.IntArg(0) + args.IntArg(1)
                    return &plugin.MethodResult{V: v}, nil
                },
            },
        },
    })
}

With the hello plugin, you can use the add method in the KCL program.

package main

import (
    "fmt"

    "kcl-lang.io/kcl-go/pkg/kcl"
    "kcl-lang.io/kcl-go/pkg/native"                // Import the native API
    _ "kcl-lang.io/kcl-go/pkg/plugin/hello_plugin" // Import the hello plugin
)

func main() {
    // Note we use `native.MustRun` here instead of `kcl.MustRun`, because it needs the cgo feature.
    yaml := native.MustRun("main.k", kcl.WithCode(code)).GetRawYamlResult()
    fmt.Println(yaml)
}

const code = `
import kcl_plugin.hello

name = "kcl"
three = hello.add(1,2) # 3

😸 KCL supports linux arm64​

KCL v0.8.0 adds support for the Linux arm64 platform in the release product.

You can find the compressed package with the suffix linux-arm64 on the KCL Release Page

🏄 SDK & API Updates​

Rust SDK​

KCL Rust SDK provides a series of APIs for compiling, validating, testing, and formatting KCL files.

KCL Rust SDK: https://github.com/kcl-lang/lib

Java SDK​

KCL Java SDK adds syntax tree, scope, symbol, and other syntax and semantic structure definitions and related query APIs.

Go SDK​

  • KCL Doc supports output in OpenAPI format.
  • Go SDK add APIs for parsing.

API Update​

  • KCL API adds API for validating JSON and YAML files.
  • Introducing syntax and semantic analysis APIs for analyzing KCL code.
  • Introducing a binary artifact build API for caching compilation results.
  • Introducing a binary artifact execution API for directly running compiled results, avoiding redundant compilation and improving performance.
  • Introducing a code generation API to programmatically implement KCL code generation instead of writing complex templates.

More updates can be found here.

🐞 Other Updates and Bug Fixes​

  • Fixed compilation errors caused by using the -S compilation parameter in KCL CLI.
  • Corrected an issue in the kcl fmt tool where an extra newline was added at the end when formatting lambda expressions.
  • Resolved an error in Schema Doc code completion snippets.
  • Fixed a recursive check error for required properties in Schema objects.
  • Enhanced the robustness of Schema index signature type checks.
  • Addressed an issue where string identifiers like “$if” were not correctly defined within Schema.
  • Optimized error messages for unexpected tokens in syntax errors.
  • Rectified variable calculations in unexpected dictionary comprehension expressions where the key and loop variable were the same.

IDE & Toolchain Updates​

IDE Updates​

IDE semantic-level highlighting enhancement​

KCL IDE previously only supported KCL syntax highlighting, as shown in the figure below:

old-ide

We have gradually introduced a new KCL semantic model in the past year. With the support of the new semantic model, KCL IDE now supports semantic-level highlighting. Code that is semantically related will be highlighted in the same way.

new-ide

For more information about the KCL semantic model, see: Unlocking Advanced Code Intelligence with the KCL Semantic Model

IDE supports completion of builtin methods​

KCL IDE supports completion of builtin methods, as shown in the figure below:

builtin-completion

IDE supports quick fix for variable reference errors​

KCL IDE supports quick fix for variable reference errors, as shown in the figure below:

quick-fix

IDE supports incremental parsing and asynchronous compilation​

IDE supports incremental parsing and asynchronous compilation through the new semantic model, which improves the compilation speed and writing experience.

More details: https://kcl-lang.io/zh-CN/blog/2023-12-09-kcl-new-semantic-model

IDE LSP bug fixes​

  • Fixed an issue where string interpolation variables in assert statements couldn’t navigate.
  • Corrected an exception-triggering issue in function autocompletion within strings.
  • Resolved an autocompletion error when a comment followed a string.
  • Fixed an issue where internal property symbols in schemas couldn’t navigate.
  • Addressed an exception in alias semantic checks and autocompletion for import statements.
  • Rectified autocompletion issues in check expressions within schemas.
  • Fixed autocompletion errors in nested schema definitions.
  • Resolved missing hover information for certain elements.
  • Ensured consistent symbol types for autocompletion across different syntaxes.
  • Distinguished between schema type and instance autocompletion symbols.
  • Standardized schema comment documentation autocompletion format.
  • Fixed issues where symbols within configuration block if statements couldn’t navigate or autocompletion was affected.

Vet Tool Updates​

In v0.8.0 release, we have optimized the diagnostic of the KCL verification tool. In the work of using the KCL verification tool to verify json/yaml files, the abnormal location of the json file will be accurately located.

Take hello.json as an example, we will verify the content of the json file through the following main.k file.

{
  "name": 10,
  "age": 18,
  "message": "This is Alice"
}

The main.k

schema User:
    name: str
    age: int
    message?: str

We can verify the content of the json file through the following command.

kcl vet hello.json main.k

We can see the error location in the json file:

error[E2G22]: TypeError
 --> test.json:2:5
  |
2 |     "name": 10,
  |     ^ expected str, got int(10)
  |

 --> main.k:2:5
  |
2 |     name: str
  |     ^ variable is defined here, its type is str, but got int(10)
  |

KCL cli supports git repository as a compilation entry​

By using the following command, you can use the KCL git repository as a compilation entry.

kcl run <git url>

kcl mod graph supports output KCL package dependency graph​

You can use command kcl mod graph to output the KCL package dependency graph.

KCL Package Management​

KCL Package Management supports adding git dependencies through commit​

KCL Package Management adds the ability to add git repo dependencies through commit. For example, using https://github.com/KusionStack/catalog，add commit a29e3db as a dependency. You can add it through editing the kcl.mod file or directly through the command line.

Edit the kcl.mod file as follows:

[dependencies]
catalog = { git = "https://github.com/KusionStack/catalog.git", commit = "a29e3db" }

Or add it through the command line:

kcl mod add --git https://github.com/KusionStack/catalog.git --commit a29e3db

KCL Package Management supports the dependency name with -​

KCL Package Management supports the dependency name with -. For example, you can add the set-annotation as a dependency through the following command:

kcl mod add set-annotation

In the KCL program, you can reference it through set_annotation.

import set_annotation

KCL Import Tool​

  • Support mapping OpenAPI multiplyOf specification to KCL multiplyof function for validation.
  • Support outputting multiple KCL files from YAML Stream-formatted Kubernetes CRD files.
  • Support generating validation expressions for OpenAPI allOf keyword.
  • Support generating validation expressions for KCL array and dictionary types using all/any.

Community Integrations & Extensions Updates​

Flux KCL Controller Release​

We have developed Flux KCL Controller to supports KCL integration with Flux. After installing Flux KCL Controller in the cluster, you can use the following resources to achieve continuous integration of KCL git repositories through FluxCD.

apiVersion: source.toolkit.fluxcd.io/v1
kind: GitRepository
metadata:
  name: kcl-deployment
  namespace: source-system
spec:
  interval: 30s
  # The URL of the git repository
  url: https://github.com/awesome-kusion/kcl-deployment.git
  ref:
    branch: main
---
apiVersion: krm.kcl.dev.fluxcd/v1alpha1
kind: KCLRun
metadata:
  name: kcl-deployment
  namespace: source-system
spec:
  sourceRef:
    kind: GitRepository
    name: kcl-deployment

More details: https://kcl-lang.io/zh-CN/blog/2024-02-01-biweekly-newsletter/

CodeQL KCL Tool​

We finished CodeQL KCL dbschema definition and data extraction for KCL syntax and semantics. We can use CodeQL to query KCL code for static analysis and scanning to improve code security.

More details: https://github.com/kcl-lang/codeql-kcl

KCL Modules Update​

There are 303 KCL modules in the KCL v0.8.0 release on https://artifacthub.io, mainly including new models related to Crossplane Provider and libraries related to JSON merge operations.

kcl run oci://ghcr.io/kcl-lang/podinfo -D replicas=2
  • JSON Schema library released version 0.0.4, fixed type definition errors. You can execute the following command to update or add dependencies.
kcl mod add jsonschema:0.0.4

Other Updates​

The full update and bugfix List of KCL v0.8.0 can be found at: https://github.com/kcl-lang/kcl/compare/v0.7.0...v0.8.0

Document Updates​

The versioning semantic option is added to the KCL website. Currently, v0.4.x, v0.5.x, v0.6.x, v0.7.0 and v0.8.0 versions are supported.

Community Updates​

KCL LFX Project KickOff​

Congratulations to @AkashKumar7902, @octonawish-akcodes, @shashank-iitbhu for being selected for the CNCF KCL LFX project, and thanks to @Vanshikav123, @Amit Pandey for their active participation.

KCL on Crossplane Function Market​

After the release of the combination function in Crossplane v1.14, the scope of using Crossplane to build cloud-native platforms has been rapidly expanded. The KCL team has followed up and proactively built a reusable function. The entire Crossplane ecosystem can now leverage the high-level experience and capabilities provided by KCL to build its own cloud-native platform.

More details: https://blog.crossplane.io/function-kcl/

Special Thanks​

Thanks to the community friends for their contributions to KCL v0.8.0. The following list is in no particular order:

  • Thanks to @jakezhu9 for the continuous contribution to the kcl import tool 🤝
  • Thanks to @octonawish-akcodes for the continuous contributions to KCL code cleanup and FAQ documentation 🙌
  • Thanks to @satyazzz123 for contributing to the support of reading environment variables in KRM KCL 🙌
  • Thanks to @AkashKumar7902 for the contributions to the package management tool feature in KCL 🙌
  • Thanks to @UtkarshUmre for the contribution to the KCL linux-arm64 build CI 🙌
  • Thanks to @octonawish-akcodes and @d4v1d03 for the continuous contributions to KCL FAQ documentation and KCL IDE feature 🙌
  • Thanks to @octonawish-akcodes for the contribution to the Ansible KCL Module
  • Thanks to @AkashKumar7902 and @Vanshikav123 for the contributions to the package management tool feature in KCL 🙌
  • Thanks to @StevenLeiZhang for the contributions to KCL documentation and KCL plugin
  • Thanks to @patrycju, @Callum Lyall, @Matt Gowie, @ShiroDN, @FLAGLORD, @YiuTerran, @flyinox, @steeling, @Anoop, @Even Solberg, @Phillip Neumann, @Naxe, @rozaliev, @CloudZero357, @martingreber, @az, @Art3mK, @Erick, @TheChinBot, @Evgeny Shepelyuk, @yonas, @vtomilov, @Fdall, @bozaro, @starkers, and @MrGuoRanDuo for their valuable suggestions and feedback during the iteration process of KCL v0.8 🙌

Next Steps​

We expect to release KCL v0.9.0 in May 2024. For more details, please refer to KCL 2024 Roadmap and KCL v0.9.0 Milestone. If you have more ideas and needs, please feel free to raise Issues or Discussions in the KCL Github repository, and welcome to join our community for discussion 🙌 🙌 🙌

Additional Resources​

For more information, see KCL FAQ.

Resources​

Thank all KCL users for their valuable feedback and suggestions during this version release. For more resources, please refer to:

See the community for ways to join us. 👏👏👏