A modern programming language that makes developers happier.

kotlinlang

I'm excited to share that *Summon*, my Kotlin frontend framework, is now published and much easier to try out!
*What is Summon?* It's a declarative UI framework that brings the elegance of Jetpack Compose to both browser and JVM environments. Think React/Vue vibes but with Kotlin's type safety and the familiar Compose API.
*Key highlights:*
• Type-safe styling with intuitive modifiers
• Component-based architecture with 40+ built-in components
• Reactive state management
• Next.js-style file-based routing
• Comprehensive theming with dark mode support
• Built-in accessibility features
• Full i18n support with RTL layouts
*The good news:* You can now easily add it to your project via GitHub Packages! No more cloning repos or building from source.
*The confession:* This is literally my first time publishing a package, so please bear with me if anything seems off! I originally tried to publish to Maven Central but kept running into CI/CD nightmares (why is publishing so hard?!), so GitHub Packages it is for now.
*Want to see it in action?* I've included working examples for both standalone JavaScript projects and Quarkus integration to help you get started quickly.
I'd love to get some feedback from the community! The framework aims to provide a compelling option for type-safe web development in Kotlin.
Check it out and let me know what you think!
*GitHub:* <https://github.com/codeyousef/summon>

Am I correct that a lot of compose code is copied verbatim?

Does the core state management work? I've created a JS app using quickstart guide, it renders initial state in the browser, but nothing gets re-rendered when the state is changed.

There is no compiler plugin in summon, right? So what is the purpose of `@Composable` annotation? How it is processed? At runtime? Is it at all? I have removed `@Composable` annotation from my code and nothing has changed.

<@U020KDMS14P> if you're asking if the api is 1 to 1 with jetpack compose then yes that's on purpose for familiarity.

<@UFT11FKSP> The state management doesn't trigger automatic re-renders - that connection isn't implemented yet.

For the @Composable annotation - yes, there's no compiler plugin. The annotation replaced an older pattern where components had to implement a `Composable` interface with a `compose()` method. I did significant refactoring to move from that interface-based approach to the annotation-based one, which allows cleaner code - now @Composable functions can directly access the composition context (like `LocalPlatformRenderer.current`) without needing to implement an interface.

While the annotation itself doesn't enforce anything at compile/runtime like Jetpack Compose does, it enables this cleaner architecture and maintains a 1-1 API with Jetpack Compose.

Thanks for pointing these out! I should definitely work on the automatic re-rendering next - that's a pretty fundamental feature that's missing.

Thanks for the answer. I'm very curious about your vision of implementing this data binding, because it's definitely not a trivial task. Existing solutions I know use compiler plugins or explicit manual bindings, but the documentation you've created promises something different. I will follow your progress. Good luck! :slightly_smiling_face: