“Today we are excited to release Kotlin 2.0 with a stable K2 compiler, which is multiplatform from the ground up, understands your code better, and compiles it twice as fast,” Egor Tolstoy, project lead for Kotlin at JetBrains, wrote in a blog post. 

One of the main highlights of this release is that it includes a stable version of the K2 compiler, which is a complete rewrite of Kotlin’s original compiler that unifies all platforms supported by Kotlin, and offers a faster and more extensible architecture, addresses technical debt from the old compiler, fixes bugs, and lays the foundation for future language extensions. 

According to JetBrains, around 15,000 developers have already used K2, and Meta has already migrated large portions of its codebase to it. 

“The everyday passion of the Kotlin community constantly motivates us to improve the language, and today, we are proud to take a huge step forward for the whole Kotlin ecosystem and release Kotlin 2.0. The new compiler architecture was built to enable us to evolve the language much easier, we can introduce new features faster and in a consistent and platform-agnostic way,” said Tolstoy.

According to JetBrains, the K2 compiler is key for multiplatform Kotlin, and to that end, Kotlin 2.0 also introduces several new features and enhancements for Kotlin Multiplatform (KMP).

Kotlin now provides first-party support for Compose Multiplatform, and the Jetpack Compose compiler (which powers Compose Multiplatform) now ships with Kotlin as of this release. 

This release also introduces an improved tooling experience for Kotlin Multiplatform. It now fully understands Xcode projects and offers full support for Swift. 

Google has also started recommending developers switch to KMP and it offers KMP support in several popular Android libraries, and has migrated some of its own apps to it as well, such as Google Docs. 

Looking ahead to the future, upcoming plans for Kotlin that the team is now working on include data recognition and deconstruction, increasing abstraction, high-performance clear code, and improving the library author experience. 

“Kotlin 2.0 significantly boosts your daily productivity. It brings a faster, smarter, and more robust compiler, as well as even better support for Kotlin Multiplatform projects. As a Kotlin developer, you get more than just a modern, concise, and safe language. You also have access to a versatile ecosystem with powerful frameworks such as Ktor and Compose Multiplatform, and combined with JetBrains IDEs, Kotlin 2.0 offers an exceptional developer experience, empowering you to build innovative, performant, and reliable applications for all platforms,” Tolstoy wrote. 

Kotlin 2.0 is now available in the latest version of IntelliJ IDEA and Android Studio. A full list of new features can be found in the language’s release notes.

The post Kotlin 2.0 now available with stable version of K2 compiler appeared first on SD Times.

“We’re dedicated to making Compose Multiplatform a framework that allows creating beautiful and performant applications that look the same way on all supported platforms,” Egor Tolstoy, project lead for Kotlin at JetBrains, wrote in a blog post, speaking about the plans for the framework for sharing UIs across platforms.  

The company’s main focus for Compose Multiplatform is to release Compose for iOS into beta. Other areas it will be working on include making all Jetpack Compose core APIs and components multiplatform, improving rendering performance on iOS, making scrolling and text editing in Compose for iOS act identically to how it does in native iOS apps, implementing a common API for resource sharing, integrating with iOS and Desktop accessibility APIs, and providing a solution for multiplatform navigation. 

It will also be working on improvements for Compose for Web, such as allowing you to port existing code; supporting varying screen sizes, orientations, and densities; supporting input from a mouse, touchscreen, physical keyboard, or onscreen keyboard; and improving performance. 

JetBrains will also be making several IDE improvements, including project configuration help, a unified debugging experience, and enhanced support for Compose Multiplatform, with features like live preview for common code and visual debugging tools. 

To support developers who want to share code with iOS targets, it will be working on a direct Kotlin-to-Swift export. “It will eliminate the Objective-C bottleneck, allowing for broader Swift language support and more natural exporting of APIs,” Tolstoy wrote.

Other initiatives in that area include improving performance for the Kotlin/Native compilation, improving CocoaPods integration, and adding support for exporting frameworks with SwiftPM. 

And finally, it will be working on improving the library ecosystem and continuing to facilitate backward compatibility. In this area the things JetBrains will focus on include improving the klib format to allow library creators to utilize their JVM library building skills, implementing the same code-inlining behavior from the JVM, and providing a tool to confirm your library’s public API hasn’t been changed in an incompatible way.

The post JetBrains reveals its 2024 development roadmap for Kotlin Multiplatform appeared first on SD Times.

Amper is designed as a tool to enhance the user experience of project configuration, particularly focused on aspects like building, packaging, and publishing. 

Its primary focus is on configuring projects for building, and it currently supports Kotlin, Kotlin Multiplatform, Java, and Swift (as a requirement for multiplatform), and the team is working on extending support to other languages and technology stacks in the future,. It is currently implemented as a Gradle plugin using YAML for project configuration,, according to the team behind the project in a post. 

The decision to use YAML over Kotlin as the markup language is driven by a desire for a declarative approach. This choice aims to simplify configuration, reduce errors, and improve tooling support. Although the decision on the markup language is not final, the JetBrains team believes that a declarative approach is crucial for achieving these goals. The use of Gradle as the underlying build tool provides a solid foundation for Amper, allowing the team to focus on creating a configuration layer to enhance the user experience.

The primary aim at this experimental stage is to gather user feedback and refine the tool’s functionality based on real-world usage and developer input.

The post SD Times Open-Source Project of the Week: Amper appeared first on SD Times.

Released in Beta in 2022, Kotlin Multiplatform allows developers to create applications for, and efficiently reuse code across, various platforms while retaining the benefits of native programming. Now stable, the framework delivers a fully-stabilized API, simplified project configuration, and better interoperability with Objective-C and Swift, as well as faster build times and other performance improvements.

“Where other technologies abstract away or completely replace platform-specific app development, Kotlin Multiplatform is complementary to existing platform-specific technologies and is geared toward replacing platform-agnostic business logic. It’s a new tool in the toolbox as opposed to replacing the toolbox,” said David Henry and Mel Yahya, Developers at Netflix.

The main benefit of Kotlin Multiplatform is its flexibility. Developers can share only part of their app’s logic and write native code if they want to interact with platform-specific APIs or build native UIs. When combining Kotlin Multiplatform with Compose Multiplatform, a declarative framework for sharing UIs across multiple platforms, developers gain even more freedom and can share up to 100% of their codebase – all in Kotlin. Compose Multiplatform is currently stable for Android and desktop, experimental for web, and in Alpha for iOS.

JetBrains continues to enhance Kotlin Multiplatform and Compose Multiplatform, as well as the tooling around them, aiming to make this combination of technologies the ultimate choice for sharing code between platforms.

“Now that Kotlin Multiplatform is stable, developers can feel much more confident about adopting it for their production projects, as JetBrains will be evolving Kotlin Multiplatform according to the strictest backward compatibility rules. Now is a great time to start using Kotlin Multiplatform for sharing code and to explore Compose Multiplatform’s capabilities for sharing UIs. We will continue improving the core technology, the libraries, and the tooling to provide the best multiplatform development experience to all,” said Ekaterina Petrova, Product Marketing Manager of Kotlin Multiplatform at JetBrains.

In addition to the improved Kotlin Multiplatform tooling, future updates will enhance the experience of iOS developers by delivering direct Kotlin-to-Swift interoperability and SwiftPM support. The next milestone for Compose Multiplatform is to deliver a Beta version for iOS in 2024. JetBrains is also actively developing Kotlin/Wasm to facilitate modern web development with Kotlin Multiplatform.

About JetBrains

JetBrains creates intelligent software development tools used by over 16 million professionals and 90 Fortune Global Top 100 companies. Its lineup of more than 30 products includes IDEs for most programming languages and technologies, such as IntelliJ IDEA, PyCharm, and others, as well as products for team collaboration, like YouTrack and Datalore. JetBrains is also known for creating Kotlin, a concise cross-platform language used for development on different platforms by more than 5 million developers worldwide yearly and recommended by Google as the preferred language for Android development. The company is headquartered in Prague, Czechia, and has offices around the world. For more information, please visit https://www.jetbrains.com/.

The post JetBrains releases Kotlin Multiplatform stable version appeared first on SD Times.

It generates Swift wrappers around the Objective-C headers that the Kotlin compiler creates. This recreates features that are supported by both languages that sometimes get “lost in the translation from Kotlin to Objective-C to Swift.” These include exhaustive sealed classes, default arguments, and suspend functions and Flows. 

This tool will make it much easier to design Kotlin APIs for use in iOS, as well as improve the experience of calling the APIs from Swift. 

SKIE was developed by TouchLab, which is a company that focuses on enabling multiplatform support for Kotlin. 

“The bottom line: Every KMP project exporting to Swift should consider trying SKIE, and every new project should have it added from the start,” TouchLab wrote in an announcement about SKIE.  

Learn more about the project by visiting its GitHub page. 

The post SD Times Open-Source Project of the Week: SKIE appeared first on SD Times.

The K2 compiler is a new frontend compiler that is planned to be released in Kotlin 2.0 as stable. It is a complete rewrite of the original compiler and offers a faster and more extensible architecture, addresses technical debt from the old compiler, fixes bugs, and lays the foundation for future language extensions. 

JetBrains plans to make K2 compatible with other compiler plugins so that it can deliver multiplatform functionality. 

“Our target is to achieve full beta-quality support for multiplatform projects in K2 concurrently with the stable release of Kotlin Multiplatform,” Sarah Haggarty, Kotlin technical writer at JetBrains, wrote in a blog post. 

In addition, a number of previously introduced features have reached the stable designation in this release. These include the replacement of the enum class values function and the ..< operator for open-ended ranges. 

New features have also been introduced, such as a new extension function for creating parent directories and a new function for retrieving the contents of a regex group by name. 

Other additions in Kotlin 1.9 include a preview of a custom memory allocator, library linkage, a preview of the Gradle configuration cache in Kotlin Multiplatform, and changes for Android target support in Kotlin Multiplatform. 

More information is available in the blog post.

The post Kotlin 1.9 brings K2 compiler in Beta appeared first on SD Times.

According to JetBrains, logic elements can often fall out of sync when dealing with mutliple codebases, so being able to share code will help eliminate issues that arise as a result of that. 

Developers can also use a single language, rather than having to use a different language for each platform they are trying to build for. 

“Where other technologies abstract away or completely replace platform specific app development, Kotlin Multiplatform is complementary to existing platform specific technologies and is geared towards replacing platform agnostic business logic. It’s a new tool in the toolbox as opposed to replacing the toolbox”, said David Henry & Mel Yahya at Netflix.

During the alpha program, JetBrains implemented an automatic memory manager to reduce some of the restrictions that were in place regarding object sharing between threads. Another benefit of this is that they can now provide fully leak-free concurrent primitives that don’t require any special management from developers.

In the beta, this memory manager is being updated to provide a more consistent experience between Android and iOS targets. According to JetBrains, this gives developers a better balance between being able to reuse Kotlin code and being able to access features that are specific to a certain platform.

The post JetBrains releases beta of its cross-platform Kotlin development tool appeared first on SD Times.

In addition to performance improvements, the goal of the new K2 compiler is to speed up development of new features in the language, unify the platforms Kotlin support, and provide an API for compiler extensions. In its current form, it is only available for the JVM and none of the compiler plugins are functional yet. 

Incremental compilation now supports cross-module changes, and support for compilation avoided also was improved. According to JetBrains, Kotlin developers who use the build cache or are often making changes in non-Kotlin Gradle modules will see the most benefit from these updates. 

Kotlin 1.7.0 also introduces an underscore operator that can be used to automatically infer a type argument when other types have been specified. 

As of this release, developers will also be able to utilize implementation by delegation to create lightweight wrappers that usually don’t allocate memory.

This release also brings a number of existing features to “stable” status, including opt-in requirement annotations, definitely non-nullable types, and builder inference. 

The post Kotlin 1.7.0 now available with alpha version of K2 compiler appeared first on SD Times.

New features and capabilities include the ability to perform code analysis for Kotlin apps for mobile development, which is an early-stage beta release, and Intelligent SCA for Python and Golang, which is also a beta release, that allows developers to identify attackable open source vulnerabilities in their code.

The release also includes workflow enhancements like improved build rules that allow for  automatic detection and interception of attacker reachable open-source vulnerabilities, interactive remediation that enables developers to specify custom validation for the tool to recognize in scan results, enhanced vulnerability descriptions, branch selection, and richer data flow visualizations. 

“Customers are already using ShiftLeft CORE to make security fixes earlier in the development cycle where they are less painful for devs and result in significantly less security debt for the application. That said, the increased frequency of scans and greater volume of vulnerability information can create information overload,” said Alok Shukla, the VP of products at ShiftLeft. “The ‘Velocity Update’ to ShiftLeft CORE helps them easily browse and triage high volumes of attackable dataflows and intelligently automate build decisions based on attackability exposure in each pull request.”

The post ShiftLeft CORE gets new vulnerability identification features appeared first on SD Times.

Users can now create Kotlin apps on desktop and can build production-quality dynamic web experiences using Compose for Web’s stable DOM API with full interoperability with all browser APIs on the web. 

Since Compose Multiplatform is declarative, the code reflects the UI structure of the app so that users don’t have to worry about copying data from model to view or developing UI refreshing logic. 

“It’s easy to get started with Compose Multiplatform, especially if you’ve used a declarative UI framework like React or Jetpack Compose by Google before. Compose Multiplatform uses many of the same concepts, so you should feel right at home,” JetBrains wrote in a blog post which contains additional details on Compose Multiplatform 1.0.

The platform uses Skia, a well-optimized graphics library that is used by many performance-sensitive applications including modern browsers. 

It also offers short iteration cycles via the Preview Tool that allows users to fine-tune their components/parts of the UI, and create multiple iterations of them without having to rebuild or restart the application, shortening the development cycle.

Beyond the Desktop, Compose Multiplatform gives users a powerful, declarative Kotlin/JS API for working with the DOM.

The post JetBrains Compose Multiplatform reaches 1.0 release appeared first on SD Times.