voyager jetpack compose

Search code, repositories, users, issues, pull requests...

Provide feedback.

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly.

To see all available qualifiers, see our documentation .

• Notifications

🛸 A pragmatic navigation library for Jetpack Compose

adrielcafe/voyager

Folders and files, repository files navigation.

Voyager : Compose on Warp Speed

A multiplatform navigation library built for, and seamlessly integrated with, Jetpack Compose .

Create scalable Single-Activity apps powered by a pragmatic API :

Turn on the Warp Drive and enjoy the voyage 🖖

Documentation

See the project website for documentation and APIs.

• Supported platforms : Android, iOS, Desktop, Web.
• Linear navigation
• BottomSheet navigation
• Tab navigation like Youtube app
• Nested navigation (multiple stacks, parent navigation)
• ScreenModel (a.k.a ViewModel) integrated with Koin , Kodein , Hilt , Coroutines , RxJava , LiveData
• Android ViewModel integration (with Hilt support )
• Type-safe multi-module navigation
• State-aware Stack API
• Built-in transitions
• State restoration after Activity recreation
• Lifecycle callbacks
• Back press handling
• Deep linking support

Releases 31

Sponsor this project, contributors 21.

• Kotlin 100.0%

Get in Touch

Voyager: The Navigation Library for Kotlin Multiplatform and Compose Multiplatform

Learn how Voyager handles navigation in a cross-platform app

Introduction

Voyager is a new navigation library built specifically for Compose multiplatform, which is designed to make navigation in Compose-based apps simpler and more intuitive.

It offers a composable API that allows developers to create screens with minimal effort, and provides an easy-to-use navigation stack that supports push, pop, replace , and other common navigation operations.

With Voyager, developers can build complex, multi-screen apps with ease, and can take advantage of Compose’s powerful tooling and state management capabilities to create responsive and performant UIs.

Open source template

Before continuing, we made an open source template for Kotlin multiplatform and Compose Multiplatform. Navigation with Voyager is setup. But that’s not all : UI, DI, offline cache, multiplatform localization and resources. All of this is setup.

Open source template with voyager

This is a version of AppKickstarter with very limited features but yet useful setup.

Back to our guide.

Why it’s important for Compose multiplatform applications

Voyager offers a unified approach to navigation in a multiplatform Compose project.

By using Voyager in the shared module of the app, there’s no need to duplicate the navigation implementation for each platform, reducing the development effort and improving the code maintainability.

Additionally, Voyager offers seamless integration with Compose’s lifecycle and state management, making it a powerful and efficient solution for multiplatform navigation in Jetpack Compose.

Basic setup of Voyager

In your MainActivity (or any other activity that uses Jetpack Compose), use the Navigator composable to set up your app’s navigation:

Use the push method of the Navigator instance to navigate to a new screen. Here is an example of how you can navigate from the HomeScreen to the DetailScreen:

This code sets up the Navigator with the HomeScreen as the initial screen. The push method is used to navigate to the DetailScreen when the user taps the “View details” button. The LocalNavigator is used to get a reference to the current navigator instance.

Screen models, state management, coroutine and Koin integration

State management is a crucial part of any mobile app. Voyager’s StateScreenModel is a helpful tool for managing screen state and updating the UI based on changes to that state. The StateScreenModel class extends the ScreenModel interface and provides a mutable MutableState property that can be used to hold and update the current state of the screen.

To use the StateScreenModel in a Voyager screen, you can define a sealed class that represents the possible states for your screen. For example:

Then, define a StateScreenModel that takes the initial state as a parameter:

One of the benefits of using Voyager’s StateScreenModel is the reduction in code required for state management.

Since StateScreenModel integrates a mutable state, there’s no need to manually define a public StateFlow for the state and a private mutableStateFlow for the same state. This saves developers from writing a lot of template code and reduces the likelihood of errors.

Coroutines integration

As you can see in this code, Voyager integrates seamlessly with coroutines.

It makes it easy to manage asynchronous operations within screen models.

Screen models in Voyager come with a coroutineScope property that allows you to launch coroutines and ensure they are properly cancelled when the screen model is disposed.

The getPerson function launches a coroutine using coroutineScope.launch . This allows you to perform asynchronous operations such as network requests, database queries, and other time-consuming tasks without blocking the UI thread.

Integration of dependency injection with Koin

You can then use this StateScreenModel in your screen and update the state as needed, which will automatically trigger a recomposition of the UI.

In your screen, you can then inject the screen model using the getScreenModel() function from the koin voyager library. Here is an example:

Voyager integrates well with the Koin dependency injection framework. It allows for easy management and injection of dependencies into screen models. To use Koin with Voyager, you will need to include the Koin dependency in your project and define your Koin modules.

To define a Koin module for a screen model, you can use the factory component and provide a lambda that returns an instance of the screen model. Here is an example:

Voyager comes with a built-in transition mechanism that allows you to create smooth transitions between screens.

To use the transition mechanism, you can pass a Transition instance to the Navigator composable.

The Transition instance defines how the transition should be animated.

For example, the following code shows how to use the SlideTransition to animate the transition between screens:

In this example, the SlideTransition is used to animate the transition between screens. The SlideTransition takes the navigator object as an argument, which is used to get the current screen and the previous screen. The SlideTransition then animates the transition between these screens by sliding the new screen in from the right.

There are several other built-in transitions available in Voyager, such as the FadeTransition and the ScaleTransition. You can also create your own custom transitions by implementing the Transition interface.

Why we love Voyager

At AppKickstarter , we love using Voyager because it is an efficient solution for implementing navigation in our Kotlin Multiplatform projects. Voyager solves the problem of duplicate navigation code in our Android and iOS projects by providing a shared navigation module.

Additionally, its integration with popular Kotlin tools such as Koin and Coroutines makes it easy to manage dependencies and asynchronous tasks.

Open Source template with Voyager

We offer a free and open source template for building multiplatform apps using Compose multiplatform and Voyager.

Our template includes everything you need to get started, from setting up Voyager to defining screens and injecting dependencies using Koin.

Upgrade Your Cross-Platform App Development with AppKickstarter

For those looking for additional features and dedicated support, we also offer a premium version called AppKickstarter.

With AppKickstarter, you’ll have access to features such as authentication with Firebase, data storage with Firebase and SqlDelight, onboarding screens, and payment integration with RevenueCat.

Our team is dedicated to providing you with the support you need to build the best possible cross-platform app.

If you’re interested in learning more about AppKickstarter and how it can help you take your project to the next level, please visit our website to learn more and purchase your license today.

Upgrade with AppKickstarter

We believe that AppKickstarter is the ultimate tool for building high-quality cross-platform apps, and we’re confident that you’ll love using it as much as we do.

Start Earning Money on Stores by Shipping Your App At Lightning Speed

AppKickstarter © 2024

[email protected]

Free AppKickstarter version (save 2 hours)

We're passionate about making Kotlin and Compose Multiplatform resources widely accessible. That's why we've created a free template just for you. Claim yours now!

Get Free Template

Painless, Typesafe Jetpack Compose Navigation with Voyager

LATEST ANDROID JOBS

update your work life

Android developer

Technical Integration Supporter

Senior Software Engineer, Mobile SDK

More dev content.

check out more videos and blogs

Automation of code analysis in Android projects

Unpacking android security: part 2 — insecure data storage, streamlining success - how we went from prototyping an sdk to serving billions of customers.

Streamlining Success – How we went from prototyping an SDK to serving billions of customers

On-device machine learning in android: frameworks and ecosystem, safe compose arguments: an improved way to navigate in jetpack compose — part 3, panel discussion: what hiring managers are really looking for - americas edition, panel discussion: what hiring managers are really looking for – americas edition.

View all posts

Leave a Reply Cancel reply

Your email address will not be published. Required fields are marked *

Post Comment

Compose Navigation — A great choice for large Android apps

Marcin Piekielny

It’s been a while since Jetpack Compose moved to Stable and became a preferred way of building a UI in Android applications. During the last two years, I had an opportunity to work with this new technology on several different projects. They were both new ones built from scratch, as well as old ones, migrated from classic XML layouts.

I was part of different teams, working with different developers, but one aspect of Compose was a common point of confusion and uncertainty. This one thing is Compose Navigation.

Navigating with Compose | Jetpack Compose | Android Developers

The navigation component provides support for jetpack compose applications. you can navigate between composables while….

developer.android.com

Now everything is upside down

Many of us, including me had a lot of doubts if this is a production ready solution. The Compose Navigation is very different from what we are used to when working with fragments.

Previously we’ve been creating an instance of a given fragment and committing it to the fragment manager. In case of the Jetpack Navigation, corresponding directions objects were generated based on the XML navigation graphs.

Now the navigation relies on the string routes. Very similar to how the web applications work. Navigation graphs are defined directly in the composable functions and each destination in the graph has a route set. We are using the same route to navigate to that destination. One thought which came to my mind initially was.

Mom, can we have mobile app at home? I don’t like web apps with URLs. No. There is a mobile app at home. Mobile app at home …

Looking for some alternatives

At the beginning I rejected the existence of this official library and started looking for some alternative. Keeping fragment-based navigation was an obvious first choice. Fragments can work as containers where we put the Compose UI while keeping navigation the old way.

But no one really wants to stay with old solution where there are new possibilities available. My second attempt was to try some 3rd party solutions. Two of them are really promising and deserve to be highlighted in this article.

GitHub - adrielcafe/voyager: 🛸 A pragmatic navigation library for Jetpack Compose

🛸 a pragmatic navigation library for jetpack compose - github - adrielcafe/voyager: 🛸 a pragmatic navigation library…, github - raamcosta/compose-destinations: annotation processing library for type-safe jetpack…, annotation processing library for type-safe jetpack compose navigation with no boilerplate. - github ….

However, any 3rd party tool, especially a new and relatively young one, carries some rick. We do not know how long it will be maintained and supported by its creators. When we rely heavily on such a tool and it gets abandoned, we may face a difficult choice: keep an unsupported solution or migrate to another one in a costly manner. Therefore, I was not convinced that choosing any of them is the right long-term decision.

Everyone deserves a chance, even the Compose Navigation

With a lot of scepticism I started playing around with this web-ish navigation solution. Initially in private projects, then through small proof of concepts in commercial ones, building complete business features, up to the delivery of entire applications with 100% Compose Navigation.

And I have to surprise you. After this journey I see great potential in this technology. It simplifies many aspects of mobile app navigation, allows the implementation of non-trivial business flows and, most importantly, scales very well in large, modular applications. Sounds interesting? So sit back and enjoy reading 🚀

One talk from Android Dev Summit that changes everything

An original documentation of the Compose Navigation library was very superficial. All the examples show navigation logic build with hardcoded string routes. We can all agree that this is not very bulletproof approach. It also misses some wider context how to build full flows and structure the implementation in a real world codebase.

But luckily, in 2022 the Android Dev Summit happened. During this event Google showed us much more details on how to use the Compose Navigation. They also published a new documentation page which describes concepts from the talk. Below you can find links to both of them.

Type safety in Kotlin DSL and Navigation Compose | Android Developers

This page contains best practices for providing runtime type safety to the navigation kotlin dsl and navigation…, the idea is simple, instead of using hardcoded strings everywhere, we create named extensions.

That’s all and that’s it. We don’t have to build any super complex, generic and custom navigation framework on our own. We just create two very simple extension functions for each individual screen in the application.

One is an extension of the NavController . It allows us to navigate to the given screen. Second one extends NavGraphBuilder . We use it to include selected screen as a destination in the NavHost .

The second extension also connects the screen composable with a corresponding view model. When we use Compose Navigation, view models live as long as destinations in the NavHost , which we create using composable(route) function.

We may notice here, that screen doesn’t perform any navigation on its own. It just exposes navigation events which are simple lambdas. And why do we do so? Why not just pass NavController object to the screen? So let me answer you 😄

One place where we can understand the entire navigation flow

A great advantage of the original Jetpack Navigation library was the visual representation of the navigation graph. It is very intuitive to take one graph file and see what screens open one by one.

In Compose Navigation we no more use XML graphs but our navigation extensions help us build equally readable graphs directly in the Kotlin code.

This is a single source of truth of how navigation works in our application. Based on the above graph we know than from the homeScreen we can move to the loginScreen and to the productScreen . And from the login screen we go further to the forgotPasswordScreen . All this information in one place. No more jumping through dozens of files to understand what the screen order is 🎉

Big application are not so simple. Can we scale it?

The example above looks nice, but real world applications are not as simple as 4 or 5 screens which we can put in a single NavHost . If our application has 20, 50 or 100 screens, we don’t want to have thousands of lines of code in one file. Readability would be extremely poor and maintenance very difficult.

At this point, we should keep in mind, that our applications are not just big pools of screens. If we treat them so, we end up with a juicy spaghetti 🍝 where understanding how user moves around the app is extremely difficult. In fact, every application splits into smaller business flows. Each flow is a set of screens that together create some broader business functionality.

Let’s think of an e-commerce application. What is a main purpose of such an app? Buying products! So this application for sure has an order flow, where user selects delivery, enters his address, chooses how to pay, confirms all the information and so on.

To make ordering easier we let user to have an account in our application. This way he can speed-up next orders because we already know where to deliver them and what delivery option user prefers. We need flow where user can login to the application. It might happen that user forgot his password so we let him to reset it as well.

And what if user is already logged in and wants to modify some of his data? No problem. In the my data flow he can edit addresses, change password or even delete the account completely.

Just 3 flows and already a lot of screens

15 screens to be precise and we still miss many aspects of an e-commerce application. What about browsing products with proper filters, viewing selected products with all the details, available variants, sizes etc. We might also want to have a list of favorite products, special offers with promo codes, general settings and maybe some loyalty program to collect points and keep user engaged.

As we can see, they are different flows of the application and each of them includes its own unique screens. The codebase should reflect this structure of our business. It applies also to the navigation implementation. Login flow doesn’t need to know anything about the delivery or payment. From the product browser we don’t need to access password settings. At the same time editing saved delivery addresses doesn’t involve any information about user’s favorite products.

I believe we all get the point now. However, one question remains — how to implement it? Do we have some mechanism to split our navigation to reflect different flows of the application?

The answer is yes, we have nested graphs

This is where Compose Navigation really shines. Nested graphs fit perfectly into multi-module applications and I highly recommend using both nested graphs and modularity in larger projects.

In this approach each business flow of the application is implemented in a separate module. Single module may contain one or multiple screens, depending on the case. All the screens have visibility set to internal so they are not visible for other modules. The same applies to their corresponding view models as well as navigation extension which we discussed earlier. The only public unit in the module is the navigation graph which is the entry point to a given flow. In the example below it is the OrderGraph .

We implement nested graphs very similarly to screens, using extension functions. Just like screen, each graph is assigned a specific route.

NavController extension is exactly the same as the one we had for screens. The one which extends NavGraphBuilder differs a bit. We use a navigation function instead of composable to define a nested graph. Inside of it we can add screens and set the start destination, same as we did for the standard NavHost.

We also pass an instance of NavController so the nested graph can navigate across internal screens. Nested graphs are not supposed to have their own NavController , they share it with a root NavHost .

So how do we move from one flow to another?

Nested graphs are fully autonomous and independently navigate between screens within the same module. But what if we want to navigate outside this module?

Let’s assume that when placing an order, the user wants to see the details of one of the ordered products. In that case we need to move user from the OrderGraph which is inside the :order module to the ProductCardGraph which is inside the :product-card module. Does it mean that these modules have to depend on each other right now?

We keep nested graphs and their modules fully independent

The key to good modularity is to keep individual modules as independent as possible. We don’t want to introduce a direct dependency between two different modules just because we need to navigate from one to another.

And luckily, with Compose Navigation we don’t have to. All we need to do is to expose navigation events from our nested graphs. We do it using lambda parameters, same as we did for screens.

App module combines all the nested graphs

Navigation events exposed by the nested graph simply communicate what navigation should be performed and eventually pass some required arguments.

The rest of the job is done by the :app module. It combines all the nested graphs into a single NavHost and handles navigation events which they expose.

This way we keep all our feature modules fully independent from each other. The :app module is the only module which knows about all the different features of the application.

Adding a bottom navigation

Real world applications quite often rely on popular navigation patterns like bottom navigation bar or navigation drawer. Adding such a solution to our codebase can significantly increase the complexity of navigation.

Let’s thing about the bottom navigation bar. Now we have to consider two different levels of navigation. First level takes an entire screen space. Second one operates in a smaller container, where navigation bar is always visible at the bottom of the screen.

Compose Navigation let’s us create multiple levels of navigation by creating separate NavHost composables. Each of them has its own NavController and we can nest one inside the other.

In that case, we need to have two different NavHost containers. On the first level we switch between full screen flows. We can distinguish the LoginGraph , the OrderGraph but also the NavigationBarHost which contains another NavHost .

On the second level, inside the NavigationBarHost we switch between flows, where there is a navigation bar displayed on the screen. Here we will find HomeGraph , CartGraph , ProfileGraph and several others.

Common nested graph inside the bottom navigation

But in complex application, bottom bar is not always jus a simple switch mechanism for showing different tabs. We can go deeper into each tab creating a nested navigation inside each of them.

In our e-commerce app we have 5 different tabs where each of them has its own nested graph:

• CategoryBrowserGraph
• FavoritesGraph
• ProfileGraph

But at the same time, we have other nested graphs that can be open in scope of different tabs. An example of such a flow is a ProductCardGraph which we can navigate to from 4 different graphs.

To achieve it we don’t need to introduce any direct dependency between individual graphs which represent the bottom navigation tabs and the ProductCardGraph . We can still keep these graphs and their modules fully independent.

All we need to do is to include the ProductCardGraph inside the NavigationBarHost composable and navigate to it through navigation events exposed by other graphs which represent main tabs of the bottom navigation bar.

Don’t forget about the indicator

One missing part is a logic to display an indicator on a proper item of the NavigationBar . To achieve it we define a list of routes which are considered as main tabs.

Then we add a function which uses a NavController , takes a currentBackStack from it and checks which tab is the last one in the back stack.

Lastly we use it in the NavigationBar to show and hide indicators for particular items.

Opening dialogs, including full screen ones

When our flow moves deeper inside the NavigationBarHost we might want to open a single screen which is displayed above the NavigationBar and takes a full screen space. In the my data flow we have several such screens. We use them mostly as forms to input or edit some information like user personal data, address or passsword.

In that case we don’t need to move user from the NavigationBarHost to the RootHost just because we want to display a single screen which takes a full screen space. It is a nice solution to use a full screen dialogs in such a scenario, as they are directly supported by the Compose Navigation.

Dialogs - Material Design 3

Dialogs provide important prompts in a user flow. they can require an action, communicate information for making….

m3.material.io

Small change and our screen becomes a full-screen dialog

When we define for instance the ChangePasswordNavigation we make it the same way we did for other screens. The only difference is that we use a dialog function instead of a composable in our NavGraphBuilder extension. We also set the usePlatformDefaultWidth to false so the dialog can take a full screen space and be a full-screen dialog.

We can achieve the same result not only for dialogs but also for the bottom sheets. Although they are not supported in the stable Navigation Compose, we can find an alpha version as part of Google Accompanist .

Just look how easy it is to add deep links

So we see how solid the Compose Navigation is when it comes to building large, scalable, mutli-module applications which contain many different flows with dozens of screens. But there is one more thing which it does really well — deep links.

In real world apps it is a crucial business requirement to be able to open certain parts of the application from external links. They are usually sent to user via e-mails, sms messages or push notifications. In various projects I saw many different solutions which were supposed to handle deeplinks in the application. They were usually very custom, heavy and complex ones.

With the Compose Navigation this whole complexity can be significantly reduced. Because our main navigation relies on the URLs we basically have a support for deep links out of the box. With two simple steps we can deeplink to any destination in the app. It doesn't matter if this is a single screen, a whole nested graph or even a dialog or a bottom sheet.

Each NavGraphBuilder extension which we used in this article has an additional deepLinks parameter. Because we already have our ROUTE constants defined we can reuse them as deep links. We just add a BASE_DEEP_LINK to them.

This BASE_DEEP_LINK is a simple base URL which is global for our application. It allows Android to decide which deep links are passed to our app and which are not.

And this decision is made based on the intent-filter which we set for our MainActivity in the Manifest file. The host attribute takes exactly the same value as the BASE_DEEP_LINK .

And that’s it. No more setup, no custom implementation, Compose Navigation will do the rest opening a selected destination. What’s even better, it properly handles back stack recreation based on our graphs declaration. For example when we deep link to the /forgot-password screen and we click back, we don’t exit the app. We move to the login screen and from the login we navigate back to home.

It has been a long journey for me that started with a lot of skepticism and rejection of this new route-based navigation pattern for Android. However, after a long time, many experiments and checking various alternatives, I have come to very solid conclusions.

Compose Navigation is actually a convenient and definitely a production-ready solution. Indeed, route-based navigation looks strange at the beginning, but when you wrap it with simple extension functions it starts to work really well. And you can support deep links at almost zero cost 💰

This library simplifies many aspect of Android navigation, offering a great back stack management, even in complex scenarios like bottom navigation with nested flows.

And what’s the most important, it scales very well in large, mulit-module projects. We can easily divide our application into fully independent features, each of which has its own autonomous navigation graph. The individual graphs become single source of truth to understand how the navigation behaves in certain features.

So? Will you give it a try?

I hope I have dispelled your fears 👻 at least a little and you’ll try to play around with Compose Navigation in your projects. Route based navigation is not so scary as it seems to be 😄

And if you want to see the source code used in this article, check out my repository where I built a sample e-commerce application, with an extensive navigation structure, a lot of screens nicely divided into 11 modules, with independent nested graphs.

GitHub - Maruchin1/android-navigation

Contribute to maruchin1/android-navigation development by creating an account on github..

Written by Marcin Piekielny

More from marcin piekielny and itnext.

Android Data Repository — A simple pattern that we often misunderstand

Scaling android architecture #5.

Martin Heinz

Modern Git Commands and Features You Should Be Using

It’s not 2005 anymore and git offers more than just add, commit, push and pull. let’s explore all the new, modern git commands, that you….

Vitalii Shevchuk

🔥 Top 7 Mind-Blowing JavaScript Features for 2024

Javascript is a powerful and versatile programming language that is constantly evolving. in 2024, we can expect to see a number of new….

Multiplatform Coroutines tips and trick

Kmm architecture #6, recommended from medium.

Jetpack Compose Bottom Navigation Bar

In this tutorial we will use material 3 to build a bottom navigation bar that has a clean api design and is easily reusable….

Narayan Panthi

Kt. Academy

Everything about Jetpack Compose Navigation

Learn about nested, bottomappbar, and dialog navigation— in jetpack compose.

Stories to Help You Grow as a Software Developer

General Coding Knowledge

Staff Picks

Medium's Huge List of Publications Accepting Submissions

Attila Akinci

Modern Android App Template with Jetpack Compose

Androidtemplate is a android application template for core logics and also technical integrations..

Ahmed Khater

Navigation in Jetpack compose.Advanced Full guide passing arguments — Clean Architecture .

Certainly here’s a breakdown of key points about navigation in jetpack compose:.

ProAndroidDev

Mastering Android ViewModels: Essential Dos and Don’ts Part 1 🛠️

If you’re using viewmodels keep these in mind for better code quality.

Michal Ankiersztajn

Stackademic

MVI Architecture Explained On Android

Mvi is getting more and more popular. what is mvi how to use it why should you use it.

Text to speech

Save Instance: Screen Navigating Jetpack Compose with Voyager Library

Abstract: Learn how to use Voyager Library for efficient screen navigating in Jetpack Compose.

Save Instance State in Screen Navigating Jetpack Compose Voyager Library

When building mobile applications using Jetpack Compose and the Voyager library for navigation, it is important to understand how to save and restore instance state. This is especially crucial when navigating between screens, as the system may destroy the current screen to free up resources. In this article, we will explore how to save and restore instance state in a screen navigating scenario using Jetpack Compose and the Voyager library.

The Scenario

Let's consider a scenario where we have a list of items fetched from an API. When the user clicks on an item, they are taken to a new screen (Screen B) displaying more details about the selected item. When the user clicks the back button, Screen B is destroyed and the user is taken back to the original list screen. In this scenario, we want to ensure that the selected item remains highlighted after the user navigates back to the list screen.

Saving Instance State

To save instance state in Jetpack Compose, we can use the rememberSaveable function. This function allows us to save and restore state across configuration changes and process death. To use rememberSaveable , we first need to define our state using a mutableStateOf function. For example:

In this example, we are defining a selectedItem state variable that will hold the index of the selected item. We are initializing it to -1, which represents no selection.

Next, we need to update the state variable when the user clicks on an item in the list. We can do this using the LaunchedEffect function, which allows us to execute code when a specific event occurs. For example:

In this example, we are updating the selectedItem state variable to the index of the clicked item. We are using the LaunchedEffect function to ensure that the state is only updated when the item actually changes.

Restoring Instance State

To restore instance state in Jetpack Compose, we can use the rememberSaveableState function. This function allows us to restore saved state when the screen is recreated. To use rememberSaveableState , we first need to define our state using a mutableStateOf function. For example:

Next, we need to restore the state variable when the screen is recreated. We can do this using the rememberSaveableState function. For example:

In this example, we are using the by keyword to automatically restore the state variable when the screen is recreated. We can then use the selectedItem state variable to highlight the selected item in the list.

Using the Voyager Library

To use the Voyager library for navigation, we first need to define our screens. We can do this using the Screen class provided by the library. For example:

In this example, we are defining two screens: ListScreen and DetailScreen . The ListScreen displays a list of items and handles item clicks, while the DetailScreen displays the details of the selected item.

Next, we need to define our navigation graph. We can do this using the NavHost component provided by the Voyager library. For example:

In this example, we are defining a navigation graph with two screens: ListScreen and DetailScreen . We are using the composable function to define each screen and passing in the corresponding Screen object as the first argument.

• To save instance state in Jetpack Compose, we can use the rememberSaveable function and the mutableStateOf function.
• To restore instance state in Jetpack Compose, we can use the rememberSaveableState function and the mutableStateOf function.
• To use the Voyager library for navigation, we can define our screens using the Screen class and define our navigation graph using the NavHost component.
• Saving States in Jetpack Compose
• Voyager Library

Discover the benefits and implementation of using Voyager Library for screen navigation in your Jetpack Compose projects.

Get time and assign variable in typing game.

In this tutorial, we will learn how to get the current time and assign it to a variable in a JavaScript typing game.

Implementing a No-Login Authentication System Without Using Cache: A Common Startup Challenge

In today's fast-paced web application development world, implementing a no-login authentication system without using cache is a common challenge faced by startups. This article explores various techniques and best practices to address this issue.

Making SWIM Activation Sequences Work with STM8 External Microcontrollers

This article explains how to make SWIM (Self-Test In-circuit Verification) activation sequences work with STM8 external microcontrollers. The process involves using the timing diagram UM0470 and entering the image description phase 4 for STM8 to respond.

Keycloak OIDC Validation: Custom Attributes for Auth using CSCAPI v2

This article explores the usage of Keycloak OIDC provider with specific use cases in CSCAPI v2, focusing on the authorization process and OAuth2/authorize use parameters for custom attribute validation.

Chained Model: Implementing ValidationCheckType in Django

In this article, we will explore how to implement the ChainedModel concept in Django using the ValidationCheckType model.

Tags: :  Jetpack Compose Voyager Library Screen Navigation

Latest news

• GoLang: Implementing AES-256GCM Encryption for WhatsApp Flows API Responses
• HandleEdit: OnClick Button Not Working for Checkbox Functionality in Dolist
• Streaming Audio Files from Amazon Kinesis Video Stream using AWS Lambda and Python
• NET 5 and Linux: Resolving TLS Issue with System.DirectoryServices.Protocols accessing Active Directory
• Make Keybindings VSCode Mode Dependent: A Comprehensive Guide
• Maximum Number of Dedicated Administrator Connections Reached in SQL Server Error Log
• One-to-Many Relationships in Software Development: Images and JPG Files
• Understanding Template Parameters: struct vs alias in C++20
• Accessing Value in an Async Function using Angular
• Troubleshooting 403 Forbidden Errors: Displaying Images Instead of YouTube and Vimeo Video Players
• Applying Constraints to Nested Discriminators in Pydantic: An Elegant Way
• Incorrectly Set PTR Records: Exim SMTP Banner Displaying Server Address Instead of Domain Address
• Connecting Arduino UNO Directly to Laptop using Ethernet Shield for POST Requests
• PyTorch Geometric: Improving Node Classification with GCNN
• Ryuget: Links Failing - Understanding the Issue
• WPF Button Background Color Not Changing on Mouse Over
• Finding Name, Login, and Logout Columns in MS Excel: A Step-by-Step Guide
• Visual Studio Professional 2022: Tabular Cube Not Showing Parameters
• Method Invocation Failed: Permission Errors During Export on Shared Drives
• Sending Raw Emails with AWS SES API using PHP
• Planning Several Shape Graphs for Algorithmic Map with Terrain Factors
• Exporting PDF and Excel Files: A Solution with VBA
• Exporting Stock Data using Modularized Function R: A Step-by-Step Guide
• Using External System-Installed Scala Library for Imbalanced Dataset in PySpark: SMOTE
• Adding a New Section in DocumentStateService
• Pruning Following Grammars: A New Variant of E, Overcoming Backtracking Issues
• Oracle/PLSQL: Simple Scenario - Returning ID Created from Table Insert
• Helm Deployed DB Pod Not Coming: Uncommented Node Selectors
• Understanding the 256 Color Limit in cmd.exe: An Internal Look
• Removing Oscillations in CSpin (SPI) Communication with ESP32-DevKitCv4
• VB.Net: Copy Multiple Rows from Sheet1 to Sheet2 with Skipping 5 Rows
• Creating Triangular Charts in Power BI: A Step-by-Step Guide
• Optimizing Redis File Cache Layer with PHP
• D3.js Scale Ordinal: Not a Function?
• AR.js 3D Model: Draco Compression Issue

Write better content Grow your audience faster

Built for 𝕏 and linkedin , powered by ai, write & schedule, effortlessly.

Craft and publish engaging content in an app built for creators.

Publish anywhere

Post on LinkedIn & Mastodon too. More platforms coming soon.

@ typefully

We're launching a Command Bar today with great commands and features.

AI ideas and rewrites

Get suggestions, tweet ideas, and rewrites powered by AI.

Turn your tweets & threads into a social blog

Give your content new life with our beautiful, sharable pages. Make it go viral on other platforms too.

Powerful analytics to grow faster

Easily track your engagement analytics to improve your content and grow faster.

Share a recent learning with your followers.

Pose a thought-provoking question.

Never run out of ideas

Get prompts and ideas whenever you write - with examples of popular tweets.

I think this thread hook could be improved.

@ frankdilo

Share drafts & leave comments

Write with your teammates and get feedback with comments.

Reply with "Notion" to get early access to my new template.

@ kandros5591

Create giveaways with Auto-DMs

Send DMs automatically based on engagement with your tweets.

And much more:

Auto-Split Text in Posts

Thread Finisher

Tweet Numbering

Connect Multiple Accounts

Automatic Backups

Keyboard Shortcuts

Creators love Typefully

150,000+ creators and teams chose typefully to curate their twitter presence..

Queue your content in seconds

Write, schedule and boost your tweets - with no need for extra apps., schedule with one click.

Queue your post with a single click - or pick a time manually.

Pick the perfect time

Time each post to perfection with Typefully's performance analytics.

Boost your content

Retweet and plug your posts for automated engagement.

Start creating a content queue.

Write once, publish everywhere, we natively support multiple platforms, so that you can expand your reach easily..

Check the analytics that matter

Build your audience with insights that make sense..

Writing prompts & personalized post ideas

Break through writer's block with great ideas and suggestions..

Enjoy daily prompts and ideas to inspire your writing.

Use AI for personalized suggestions

Get inspiration from ideas based on your own past tweets.

Flick through topics

Or skim through curated collections of trending tweets for each topic.

Write, edit, and track tweets together

Write and publish with your teammates and friends..

Share your drafts

Brainstorm and bounce ideas with your teammates.

Add comments

Get feedback from coworkers before you hit publish.

Read, Write, Publish

Control user access

Decide who can view, edit, or publish your drafts.

Build an automated post machine

Our zapier integration enables countless no-code workflows..

Share new drafts in Slack channel

New draft from RSS feed item content

New scheduled draft from Google Doc

New spreadsheet row from published post

Create new template draft every Monday

Send an email for every published thread

Create draft for new items in feeds folder

Thank new followers with a post

Ready to write better content and grow your audience?

Get started with our generous free plan.

© 2024 Mailbrew Inc.

Work with us

Keyboard shortcuts

Invite teammates

Affiliate program

Typefully Academy

Get a social blog

Automate with Zapier

Boost engagement

Popular profiles

Twitter Card Validator

X Card Validator

Help & Social

Brand assets

Announcements

Discovering the Voyager Navigation Library for Jetpack Compose

Louis Duboscq

@ louisduboscq

Tired of building same features for new apps, I built a reusable template. Now I help clients grow their business: 50k-100k DAU, $7k+ MRR

Easier Navigation in Android Apps with Voyager: Voyager Navigator 1.0.0

Abstract: Voyager: Voyager Navigator 1.0.0 simplifies navigation in Android apps using Jetpack Compose. Learn more about its benefits and limitations.

Easier Navigation with Android Apps: Voyager Navigator 1.0.0

In the world of Android app development, navigation is a crucial aspect of the user experience. One of the newer libraries that aims to make navigation easier and more intuitive is Voyager Navigator, developed by Adriel Cafe. This article will provide an in-depth look at Voyager Navigator 1.0.0, including its key concepts, features, and how to use it in your next project.

What is Voyager Navigator?

Voyager Navigator is a Jetpack Compose navigation library that provides a typesafe and easy-to-use API for navigating between screens in your Android app. It was developed by Adriel Cafe, a well-known Android developer and Google Developer Expert. Voyager Navigator is designed to be a more modern and intuitive alternative to the built-in Navigation component in Jetpack Compose.

Key Concepts

At its core, Voyager Navigator is built around a few key concepts:

• Navigator: A Navigator is a component that manages a stack of screens. It is responsible for handling navigation between screens and providing a way to go back to the previous screen.
• Screen: A Screen is a single composable that represents a single screen in your app. Screens are responsible for displaying the UI and handling user interactions.
• Navigation: Navigation is the act of moving from one screen to another. Voyager Navigator provides a typesafe API for navigating between screens.

Getting Started

To get started with Voyager Navigator, you will first need to add it to your project. You can do this by adding the following dependency to your app-level build.gradle file:

Once you have added the dependency, you can start using Voyager Navigator in your app. The first step is to create a Navigator component. This can be done by creating a new composable function and annotating it with the @Navigator annotation. For example:

Once you have created a Navigator, you can add screens to it. Screens are added to the Navigator by calling the addScreen method. For example:

Finally, you can navigate between screens by calling the navigate method on the Navigator. For example:

One Drawback

One drawback of Voyager Navigator is that it does not support deep linking out of the box. This means that if you want to open a specific screen in your app from an external link, you will need to implement this functionality yourself. However, this is a relatively minor issue and can be easily worked around.

Voyager Navigator is a powerful and easy-to-use navigation library for Jetpack Compose. It provides a typesafe API for navigating between screens, making it much easier to manage navigation in your app. While it does have one drawback, this is a relatively minor issue and can be easily worked around. If you are looking for a modern and intuitive way to handle navigation in your Android app, Voyager Navigator is definitely worth considering.

• Voyager Navigator is a Jetpack Compose navigation library developed by Adriel Cafe
• It provides a typesafe API for navigating between screens
• It is designed to be a more modern and intuitive alternative to the built-in Navigation component in Jetpack Compose
• It does not support deep linking out of the box
• Voyager Navigator on GitHub
• Jetpack Compose documentation
• Navigation component documentation

Tags: :  Android Navigation Voyager Jetpack Compose

Latest news

• 14.2 Final Project: Fibonacci Sequence in Zybooks Labs
• Migrating Joomla Website to MSSQL Server Database: Password Encryption Problem
• Using Multiple Visual Studio 2022 Projects with Remote Origins and Different GitHub Accounts
• Newbie Programmer Unable to Get Game Window to Appear
• Resolving getFormIdError in Google Apps Script
• Linking to an HTML Page Outside Jupyter Notebook
• Error during JWT package upgrade: Correlation failed
• Adding Description to Google App Script Calendar Event
• Understanding VBSscripttask.vbs: Is it Malicious?
• Nginx Client Max Body Size Not Working with Docker Container on AWS EC2 Instance: A Solution
• Multithreaded Environment: Synchronizing Real-Time Data Sharing between Kafka Producer Threads
• Resolving MySQL Connection Issue in Spring Boot: Missing Table Creation in application.properties
• Troubleshooting Intermittent FileNotFoundError in MWAA for DAGs
• Postman Stuck: Sending GET Request to app.get(/users) Endpoint
• Using GiST Notation with LTREE Extension in Supabase
• Gatsby: Low Mobile Performance with Even Empty Pages
• Understanding Confused Binding Redirects with old version ranges
• Understanding VB.NET: Declaring a Byte Array with 'New Byte(-1){}'
• Boosting MTCNN Live Face Detection Performance
• Comparing and Testing the Effects of Random Perturbations in Mixed Generalized Linear Models
• Creating Empty Zip Files with dotNetZip in ASP.NET Core
• Testing Vuetify's v-select with Vue Test Utils
• Uncaught ReferenceError: num1 not defined - Comparing Three Numbers in JavaScript
• Effortlessly Convert Data in JavaScript to Word or PDF
• Adding Dashed Lines to Existing Plot with Different Dataset
• GitLab: Main Branch Mirrored Repository Diverged
• Installing Clang-17 on MacOS: A Step-by-Step Guide
• Updating a List via Database User Input: A Lesson in AI and Strips
• Python: Convert Betfair Historical Odds BZ2 Files to CSV
• Resolving Kerberos Exception when Submitting Spark Job in Cloudera YARN
• Breaking the Post Backloop in Wordpress: A Solution
• Packages Won't Install IDLE on Linux: A Solution
• Data Factory: Changing DateTime Type for Power Query Statements in Blob Storage
• Unable to Figure out Android Stacktrace Fix: java.lang.IllegalArgumentException
• Integration Tests Using Xunit: Incomplete Process After Disposing Docker Containers

Kotlin Multiplatform Development Help

Navigation and routing.

Navigation is a key part of UI applications that allows users to move between different application screens. Compose Multiplatform adopts the Jetpack Compose approach to navigation .

To use the navigation library, add the following dependency to your commonMain source set:

Sample project

To see the Compose Multiplatform navigation library in action, check out the nav_cupcake project , which was converted from the Navigate between screens with Compose Android codelab.

Just as with Jetpack Compose, to implement navigation, you should:

List routes that should be included in the navigation graph. Each route must be a unique string that defines a path.

Create a NavHostController instance as your main composable property to manage navigation.

Add a NavHost composable to your app:

Choose the starting destination from the list of routes you defined earlier.

Create a navigation graph, either directly, as part of creating a NavHost , or programmatically, using the NavController.createGraph() function.

Each back stack entry (each navigation route included in the graph) implements the LifecycleOwner interface. A switch between different screens of the app makes it change its state from RESUMED to STARTED and back. RESUMED is also described as "settled": navigation is considered finished when the new screen is prepared and active. See the Lifecycle page for details of the current implementation in Compose Multiplatform.

Consider the following implementation aspects:

The ViewModel factory allows creating ViewModel entities of the correct type on iOS and web.

The ComposeViewModelStoreOwner class implements the ViewModelStoreOwner interface to provide a fallback for platforms other than Android and desktop.

Compose Multiplatform string resources are used in place of Jetpack Compose resources.

Limitations

Current limitations of navigation in Compose Multiplatform, compared to Jetpack Compose:

Deep links (handling or following them) are not supported.

The BackHandler function and predictive back gestures are not supported on any platform besides Android.

Third-party alternatives

If the Compose Multiplatform navigation components do not solve your problems, there are third-party alternatives that you can choose from:

> code.kiwi.com _

The tech community of, type-safe arguments in jetpack navigation compose.

Jetpack Navigation Compose is the Jetpack Navigation library enhanced for usage in Compose. But the actual “enhancement” is a bit limited and different from the View-based navigation. Most importantly, there are no SafeArgs — a type-safe compile time solution for passing arguments between destinations. Navigation for Compose uses a simple URL pattern —  arguments have to be converted to a string as a query parameter/path segment .

There are plenty of possible solutions — extensions to Jetpack Navigation Compose (Compose Destinations) or completely new navigation stacks with a custom implementation of the whole concept of navigation (Voyager, Compose Navigation Reimagined, Appyx). Yet every solution lacks something for our Kiwi.com apps usage.

Requirements

There are also requirements that are supported in every navigation library, so let me rather enumerate key areas that are implemented differently or not implemented at all.

Safe argument passing  — This is the main reason why we are not satisfied with the “raw” Jetpack Navigation Compose library, which we are currently using. We want to freely pass more complex types (Parcelable/Serializable), non-primitive types like lists of ints, or even nullable primitive types. All this is either impossible or extremely verbose and complex to set up.

Deeplink support and navigation up vs. navigation back  — This is probably the greatest topic at all. Let’s take an example from our app and have this navigation flow: Main screen -> Bookings tab -> Booking detail -> Booking passenger details We are about to create a deep link to that passenger details screen. The screen requires a bookingId to show. In the case of deep link, one could imagine an URL like  example.com/bookings/123/passengers . The 123 is the bookingId. Opening this URL will open the app on the Booking passenger details screen. Then the user can:

• Navigate back using the swipe gesture/back button in the system navigation bar.  This action returns the user to the app they were before — e.g. an email client where the user clicked the link.
• Navigate up using the back arrow in the toolbar/TopAppBar.  This action goes to the previous screen in the navigation hierarchy — in this case to the actual Booking detail. What’s more important, the navigationUp should somehow “share” the bookingId from the current services screen and use it for opening the Booking detail screen.

Build speed  — The final solution shouldn’t be using KAPT or KSP. Half of our modules are about UI and making them all KSP-dependent means a non-trivial slow-down. An acceptable approach can be using a Kotlin compiler plugin.

Dialogs, BottomSheets, Animations  — One would expect that every library has solutions for dialogs, bottom-sheets, or custom animations/transitions. Actually, the Jetpack Navigation Compose library does not have bottom-sheets or custom animations/transitions, but there are official accompanying libraries — Accompanist’s  Navigation Material BottomSheet  and  Navigation Animations . Simply, we don’t want to solve all those issues once again and expect the navigation library to provide solutions for us.

NavigationUp vs Back is well supported in Jetpack Navigation Compose (and therefore it Compose Destinations). Other custom navigation libraries are letting you define the deeplink’s back stack manually. The problematic part is that the developer has to manually track which back stack entry is “artificial” and therefore going back to this entry should rather navigate to previous app (in contrast to navigating up).

As mentioned earlier, KSP used in Compose Destination is a non-trivial slow-down that we do not want to sacrifice.

Dialogs and bottom sheets are somehow supported everywhere, though not always they are part of the navigation back stack and they can be modeled separately. Jetpack Navigation Compose seems to be the way we want to go with and it is somehow “promised” that bottom sheets will be supported natively.

Currently we do not miss much. Only the type-safe navigation. If only there was a mechanism in Kotlin that would allow us compile-time arguments processing and then runtime reflection-less conversion into an URL (and runtime reflection-less recreation from Bundle, respectively). Parcelables are quite limited. But wait, isn’t Kotlinx.Serilization exactly about this? Oh yes. That’s our solution.

NavigationComposeTyped

NavigationComposeTyped is the name of our  new open-sourced library , that solves the type-safe arguments passing problem using KotlinX.Serialization .

It is a simple set of extensions to the existing Jetpack Navigation Compose library. Those extension functions allow you to define destinations with arguments, easy navigation to those destinations, and the final arguments extraction. It utilizes the official KotlinX.Serialization Kotlin compiler plugin, therefore it is fast, and the plugin promises great Kotlin compatibility.

Let’s start hacking with a simple definition of the app’s destinations including their arguments:

Next, continue with the NavGraph construction

Finally, let’s allow Home to navigate

Extensibility

The library itself is basically a set of few simple public functions:

• to create a URL pattern for a Destination,
• to create navArguments definition for a Destination,
• to decode a Destination instance (arguments) from a received Bundle,
• to register a destination is a subtype of Destination (solving open polymorphism for KotlinX.Serialization).

Those functions help you implement type-safe navigation for other Jetpack Navigation Compose extensions, e.g. for bottom sheets from Accompanist’s library. Let’s take a look.

We had about 6+ NavHost using Navigation Compose already. Coming up with a solution that adds the missing piece helps us keep the continuity and knowledge. It allows us to freely integrate other Navigation Compose extensions.

Feedback wanted

We have just started. Check out the project and feel free to  open an issue  and discuss your experience and suggestions. The whole repository is open-sourced at  github.com/kiwicom/navigation-compose-typed .

Generating SwiftUI snapshot tests with Swift macros

Don’t Fix Bad Data, Do This Instead

Social media, mailing list.

• Victor Mukhin

Victor M. Mukhin was born in 1946 in the town of Orsk, Russia. In 1970 he graduated the Technological Institute in Leningrad. Victor M. Mukhin was directed to work to the scientific-industrial organization "Neorganika" (Elektrostal, Moscow region) where he is working during 47 years, at present as the head of the laboratory of carbon sorbents.     Victor M. Mukhin defended a Ph. D. thesis and a doctoral thesis at the Mendeleev University of Chemical Technology of Russia (in 1979 and 1997 accordingly). Professor of Mendeleev University of Chemical Technology of Russia. Scientific interests: production, investigation and application of active carbons, technological and ecological carbon-adsorptive processes, environmental protection, production of ecologically clean food.   

Title : Active carbons as nanoporous materials for solving of environmental problems

Quick links.

• Conference Brochure
• Tentative Program

• History of cooperation
• Areas of cooperation
• Procurement policy
• Useful links
• Becoming a supplier
• Procurement
• Rosatom newsletter

© 2008–2024Valtiollinen Rosatom-ydinvoimakonserni

• Rosatom Global presence
• Rosatom in region
• For suppliers
• Preventing corruption
• Press centre

Rosatom Starts Life Tests of Third-Generation VVER-440 Nuclear Fuel

• 16 June, 2020 / 13:00

This site uses cookies. By continuing your navigation, you accept the use of cookies. For more information, or to manage or to change the cookies parameters on your computer, read our Cookies Policy. Learn more

For the first time Rosatom Fuel Division supplied fresh nuclear fuel to the world’s only floating nuclear cogeneration plant in the Arctic

The fuel was supplied to the northernmost town of Russia along the Northern Sea Route.

The first in the history of the power plant refueling, that is, the replacement of spent nuclear fuel with fresh one, is planned to begin before 2024. The manufacturer of nuclear fuel for all Russian nuclear icebreakers, as well as the Akademik Lomonosov FNPP, is Machinery Manufacturing Plant, Joint-Stock Company (MSZ JSC), a company of Rosatom Fuel Company TVEL that is based in Elektrostal, Moscow Region.

The FNPP includes two KLT-40S reactors of the icebreaking type. Unlike convenient ground-based large reactors (that require partial replacement of fuel rods once every 12-18 months), in the case of these reactors, the refueling takes place once every few years and includes unloading of the entire reactor core and loading of fresh fuel into the reactor.

The cores of KLT-40 reactors of the Akademik Lomonosov floating power unit have a number of advantages compared to the reference ones: a cassette core was used for the first time in the history of the unit, which made it possible to increase the fuel energy resource to 3-3.5 years between refuelings, and also reduce the fuel component of the electricity cost by one and a half times. The FNPP operating experience formed the basis for the designs of reactors for nuclear icebreakers of the newest series 22220. Three such icebreakers have been launched by now.

For the first time the power units of the Akademik Lomonosov floating nuclear power plant were connected to the grid in December 2019, and put into commercial operation in May 2020. The supply of nuclear fuel from Elektrostal to Pevek and its loading into the second reactor is planned for 2024. The total power of the Akademik Lomonosov FNPP, supplied to the coastal grid of Pevek without thermal energy consumption on shore, is about 76 MW, being about 44 MW in the maximum thermal power supply mode. The FNPP generated 194 million kWh according to the results of 2023. The population of Pevek is just a little more than 4 thousand, while the FNPP has a potential for supplying electricity to a city with a population of up to 100 thousand people. After the FNPP commissioning two goals were achieved. These include first of all the replacement of the retiring capacities of the Bilibino NPP, which has been operating since 1974, as well as the Chaunskaya TPP, which has already been operating for more than 70 years. Secondly, energy is supplied to the main mining companies in western Chukotka in the Chaun-Bilibino energy hub a large ore and metal cluster, including gold mining companies and projects related to the development of the Baimsk ore zone. In September 2023, a 110 kilovolt power transmission line with a length of 490 kilometers was put into operation, connecting the towns of Pevek and Bilibino. The line increased the reliability of energy supply from the FNPP to both Bilibino consumers and mining companies, the largest of which is the Baimsky GOK. The comprehensive development of the Russian Arctic is a national strategic priority. To increase the NSR traffic is of paramount importance for accomplishment of the tasks set in the field of cargo shipping. This logistics corridor is being developed due regular freight voyages, construction of new nuclear-powered icebreakers and modernization of the relevant infrastructure. Rosatom companies are actively involved in this work. Rosatom Fuel Company TVEL (Rosatom Fuel Division) includes companies fabricating nuclear fuel, converting and enriching uranium, manufacturing gas centrifuges, conducting researches and producing designs. As the only nuclear fuel supplier to Russian NPPs, TVEL supplies fuel for a total of 75 power reactors in 15 countries, for research reactors in nine countries, as well as for propulsion reactors of the Russian nuclear fleet. Every sixth power reactor in the world runs on TVEL fuel. Rosatom Fuel Division is the world’s largest producer of enriched uranium and the leader on the global stable isotope market. The Fuel Division is actively developing new businesses in chemistry, metallurgy, energy storage technologies, 3D printing, digital products, and decommissioning of nuclear facilities. TVEL also includes Rosatom integrators for additive technologies and electricity storage systems. Rosenergoatom, Joint-Stock Company is part of Rosatom Electric Power Division and one of the largest companies in the industry acting as an operator of nuclear power plants. It includes, as its branches, 11 operating NPPs, including the FNPP, the Scientific and Technical Center for Emergency Operations at NPPs, Design and Engineering as well as Technological companies. In total, 37 power units with a total installed capacity of over 29.5 GW are in operation at 11 nuclear power plants in Russia. Machinery Manufacturing Plant, Joint-Stock Company (MSZ JSC, Elektrostal) is one of the world’s largest manufacturers of fuel for nuclear power plants. The company produces fuel assemblies for VVER-440, VVER-1000, RBMK-1000, BN-600,800, VK-50, EGP-6; powders and fuel pellets intended for supply to foreign customers. It also produces nuclear fuel for research reactors. The plant belongs to the TVEL Fuel Company of Rosatom.

Rosatom obtained a license for the first land-based SMR in Russia

On April 21, Rosenergoatom obtained a license issued by Rostekhnadzor to construct the Yakutsk land-based SMR in the Ust-Yansky District of the Republic of Sakha (Yakutia).

ROSATOM and FEDC agree to cooperate in the construction of Russia's first onshore SNPP

ROSATOM and FEDC have signed a cooperation agreement to build Russia's first onshore SNPP in Yakutia.

Rosatom develops nuclear fuel for modernized floating power units

Rosatom has completed the development of nuclear fuel for the RITM-200S small modular reactor designed for the upgraded floating power units.