# Dioxus Stores Stores are an extension to the Dioxus signals system for reactive nested data structures. Each store will lazily create signals for each field/member of the data structure as needed. By default stores act a lot like [`dioxus_signals::Signal`]s, but they provide more granular subscriptions without requiring nested signals. You should derive [`Store`](dioxus_stores_macro::Store) on your data structures to generate selectors that let you scope the store to a specific part of your data structure. ```rust, no_run use dioxus::prelude::*; use dioxus_stores::*; fn main() { dioxus::launch(app); } // Deriving the store trait provides methods to scope the store to specific parts of your data structure. // The `Store` macro generates a `count` and `children` method for `Store` #[derive(Store, Default)] struct CounterTree { count: i32, children: Vec, } fn app() -> Element { let value = use_store(Default::default); rsx! { Tree { value } } } #[component] fn Tree(value: Store) -> Element { // Calling the generated `count` method returns a new store that can only // read and write the count field let mut count = value.count(); let mut children = value.children(); rsx! { button { // Incrementing the count will only rerun parts of the app that have read the count field onclick: move |_| count += 1, "Increment" } button { // Stores are aware of data structures like `Vec` and `Hashmap`. When we push an item to the vec // it will only rerun the parts of the app that depend on the length of the vec onclick: move |_| children.push(Default::default()), "Push child" } ul { // Iterating over the children gives us stores scoped to each child. for value in children.iter() { li { Tree { value } } } } } } ```