diff --git a/docs/api/container.md b/docs/api/container.md
index 1a6f2f1..badbbca 100644
--- a/docs/api/container.md
+++ b/docs/api/container.md
@@ -52,3 +52,68 @@ const UserTodos = ({ initialTodos }) => (
   </TodosContainer>
 );
 ```
+
+### createDynamicContainer
+
+```js
+createDynamicContainer(config);
+```
+
+##### Arguments
+
+1. `config` _(Object)_: containing one or more of the following keys:
+
+   - `displayName` _(string)_: used by React to better identify a component. Defaults to `DynamicContainer`
+
+   - `matcher` _(Function)_: a function returning `true` for stores that need to be contained. Required.
+
+   - `onStoreInit` _(Function)_: an action that will be triggered on each store initialisation. If you define multiple containers sharing the same scope, this action will still only be run **once** by one of the container components, so ensure they receive the same props.
+
+   - `onStoreUpdate` _(Function)_: an action that will be triggered when a store state changes.
+
+   - `onStoreCleanup` _(Function)_: an action that will be triggered after a store is no longer listened to (usually after container unmounts). Useful in case you want to clean up side effects like event listeners or timers. As with `onStoreInit`, if you define multiple containers this action will trigger by the **last one** unmounting.
+
+   - `onPropsUpdate` _(Function)_: an action that will be triggered when props on a container change.
+
+##### Returns
+
+_(Component)_: this React component allows you to change the behaviour of child components by providing different Store instances or custom props to actions. It accept the following props:
+
+- `isGlobal` _(bool)_: by default, Container defines a local store instance. This prop will allow child components to get data from the global store's registry instance instead
+
+- `scope` _(string)_: this option will allow creating multiple global instances of the same store. Those instances will be automatically cleaned once all the containers pointing to the scoped version are removed from the tree. Changing a Container `scope` will: create a new Store instance, make `onInit` action run again and all child components will get the data from it.
+
+- `...props` _(any)_: any additional prop set on the Container component is made available in the actions of child components
+
+##### Example
+
+Let's create a Container that contains and initializes all theme-related stores, for instance.
+
+```js
+import { createDynamicContainer } from 'react-sweet-state';
+
+// Assume we have a ColorsStore and a FontSizesStore with `tags: ['theme']`
+
+const ThemeContainer = createDynamicContainer({
+  matcher: (Store) => Store.tags.includes('theme'),
+  onStoreInit:
+    () =>
+    ({ setState, getState }, { initialTheme }) => {
+      const state = getState();
+      if ('colors' in state) {
+        // refining to colors store
+        setState({ colors: initialTheme.colors });
+      }
+      if ('fontSizes' in state) {
+        // refining to sizes store
+        setState({ sizes: initialTheme.sizes });
+      }
+    },
+});
+
+const UserTheme = ({ colors, sizes }) => (
+  <ThemeContainer initialTheme={{ colors, sizes }}>
+    <TodosList />
+  </ThemeContainer>
+);
+```
diff --git a/examples/advanced-scoped-dynamic/components/color.tsx b/examples/advanced-scoped-dynamic/components/color.tsx
new file mode 100644
index 0000000..0c8ef02
--- /dev/null
+++ b/examples/advanced-scoped-dynamic/components/color.tsx
@@ -0,0 +1,29 @@
+import {
+  createStore,
+  createHook,
+  type StoreActionApi,
+} from 'react-sweet-state';
+
+type State = {
+  color: string;
+};
+
+const initialState: State = {
+  color: 'white',
+};
+
+const actions = {
+  set:
+    (color: string) =>
+    ({ setState }: StoreActionApi<State>) => {
+      setState({ color });
+    },
+};
+
+const Store = createStore({
+  initialState,
+  actions,
+  tags: ['theme'],
+});
+
+export const useColor = createHook(Store);
diff --git a/examples/advanced-scoped-dynamic/components/width.tsx b/examples/advanced-scoped-dynamic/components/width.tsx
new file mode 100644
index 0000000..3fa1135
--- /dev/null
+++ b/examples/advanced-scoped-dynamic/components/width.tsx
@@ -0,0 +1,29 @@
+import {
+  createStore,
+  createHook,
+  type StoreActionApi,
+} from 'react-sweet-state';
+
+type State = {
+  width: number;
+};
+
+const initialState: State = {
+  width: 200,
+};
+
+const actions = {
+  set:
+    (width: number) =>
+    ({ setState }: StoreActionApi<State>) => {
+      setState({ width });
+    },
+};
+
+const Store = createStore({
+  initialState,
+  actions,
+  tags: ['theme'],
+});
+
+export const useWidth = createHook(Store);
diff --git a/examples/basic-flow/index.html b/examples/advanced-scoped-dynamic/index.html
similarity index 85%
rename from examples/basic-flow/index.html
rename to examples/advanced-scoped-dynamic/index.html
index 7738059..f012687 100644
--- a/examples/basic-flow/index.html
+++ b/examples/advanced-scoped-dynamic/index.html
@@ -2,7 +2,7 @@
 <html>
 
 <head>
-  <title>Basic example with Flow</title>
+  <title>Advanced dynamic scoped example</title>
   <style>
     body { font-family: sans-serif; }
     main { display: flex; line-height: 1.5; }
diff --git a/examples/advanced-scoped-dynamic/index.tsx b/examples/advanced-scoped-dynamic/index.tsx
new file mode 100644
index 0000000..1d8ed94
--- /dev/null
+++ b/examples/advanced-scoped-dynamic/index.tsx
@@ -0,0 +1,59 @@
+import React, { StrictMode } from 'react';
+import ReactDOM from 'react-dom/client';
+import { createDynamicContainer } from 'react-sweet-state';
+
+import { useColor } from './components/color';
+import { useWidth } from './components/width';
+
+const ThemingContainer = createDynamicContainer({
+  matcher: (Store) => Store.tags?.includes('theme') ?? false,
+});
+
+const colors = ['white', 'aliceblue', 'beige', 'gainsboro', 'honeydew'];
+const widths = [200, 220, 240, 260, 280];
+const rand = () => Math.floor(Math.random() * colors.length);
+
+/**
+ * Components
+ */
+const ThemeHook = ({ title }: { title: string }) => {
+  const [{ color }, { set: setColor }] = useColor();
+  const [{ width }, { set: setWidth }] = useWidth();
+
+  return (
+    <div style={{ background: color, width }}>
+      <h3>Component {title}</h3>
+      <p>Color: {color}</p>
+      <p>Width: {width}</p>
+      <button onClick={() => setColor(colors[rand()])}>Change color</button>
+      <button onClick={() => setWidth(widths[rand()])}>Change width</button>
+    </div>
+  );
+};
+
+/**
+ * Main App
+ */
+const App = () => (
+  <div>
+    <h1>Advanced dynamic scoped example</h1>
+    <main>
+      <ThemingContainer scope="t1">
+        <ThemeHook title="scope" />
+      </ThemingContainer>
+      <ThemingContainer>
+        <ThemeHook title="local" />
+      </ThemingContainer>
+      <ThemingContainer scope="t1">
+        <ThemeHook title="scope sync" />
+      </ThemingContainer>
+    </main>
+  </div>
+);
+
+const root = ReactDOM.createRoot(document.getElementById('root')!);
+root.render(
+  <StrictMode>
+    <App />
+  </StrictMode>
+);
diff --git a/examples/basic-flow/components.js b/examples/basic-flow/components.js
deleted file mode 100644
index 82316bc..0000000
--- a/examples/basic-flow/components.js
+++ /dev/null
@@ -1,40 +0,0 @@
-// @flow
-
-import {
-  createStore,
-  createSubscriber,
-  createHook,
-  type Action,
-  type SubscriberComponent,
-  type HookFunction,
-} from 'react-sweet-state';
-
-type State = {|
-  count: number,
-|};
-
-type Actions = typeof actions;
-
-const initialState: State = {
-  count: 0,
-};
-
-const actions = {
-  increment:
-    (): Action<State> =>
-    ({ setState, getState }) => {
-      setState({
-        count: getState().count + 1,
-      });
-    },
-};
-
-const Store = createStore<State, Actions>({
-  initialState,
-  actions,
-});
-
-export const CounterSubscriber: SubscriberComponent<State, Actions> =
-  createSubscriber(Store);
-
-export const useCounter: HookFunction<State, Actions> = createHook(Store);
diff --git a/examples/basic-flow/index.js b/examples/basic-flow/index.js
deleted file mode 100644
index b110432..0000000
--- a/examples/basic-flow/index.js
+++ /dev/null
@@ -1,34 +0,0 @@
-// @flow
-import React from 'react';
-import ReactDOM from 'react-dom';
-
-import { useCounter } from './components';
-
-/**
- * Components
- */
-const CounterHook = () => {
-  const [{ count }, { increment }] = useCounter();
-
-  return (
-    <div>
-      <h3>With Hooks</h3>
-      <p>{count}</p>
-      <button onClick={increment}>+1</button>
-    </div>
-  );
-};
-
-/**
- * Main App
- */
-const App = () => (
-  <div>
-    <h1>Simple counter example</h1>
-    <main>
-      <CounterHook />
-    </main>
-  </div>
-);
-
-ReactDOM.render(<App />, document.getElementById('root'));
diff --git a/examples/basic-ts/index.tsx b/examples/basic-ts/index.tsx
index 8788f10..f198ede 100644
--- a/examples/basic-ts/index.tsx
+++ b/examples/basic-ts/index.tsx
@@ -1,4 +1,3 @@
-// @flow
 import React, { StrictMode } from 'react';
 import ReactDOM from 'react-dom/client';
 
diff --git a/examples/performance-scale-test/index.js b/examples/performance-scale-test/index.js
index d5cce68..f7fb574 100644
--- a/examples/performance-scale-test/index.js
+++ b/examples/performance-scale-test/index.js
@@ -5,6 +5,7 @@ import ReactDOM from 'react-dom/client';
 import { useTodo } from './controllers/todos';
 
 const COLLECTION = Array.from({ length: 500 });
+const ONE_EVERY = 10;
 
 type TodoViewProps = { id: string, count: number };
 
@@ -27,13 +28,22 @@ const TodoView = ({ id, count }: TodoViewProps) => {
  */
 const App = () => {
   const [count, setCount] = useState(0);
+
+  useEffect(() => {
+    setTimeout(() => setCount((c) => c + 1));
+  });
+
   return (
     <div>
       <h1>Performance</h1>
       <button onClick={() => setCount(count + 1)}>Trigger</button>
       <main>
         {COLLECTION.map((v, n) => (
-          <TodoView key={n} id={String(n)} count={count} />
+          <TodoView
+            key={n}
+            id={String(n)}
+            count={Math.floor(count / ONE_EVERY)}
+          />
         ))}
       </main>
     </div>
diff --git a/src/__tests__/mocks.js b/src/__tests__/mocks.js
index 51ce8fa..202e0cc 100644
--- a/src/__tests__/mocks.js
+++ b/src/__tests__/mocks.js
@@ -21,9 +21,3 @@ export const storeStateMock = {
   listeners: () => [],
   mutator: () => {},
 };
-
-export const registryMock = {
-  configure: jest.fn(),
-  getStoreState: jest.fn(),
-  deleteStoreState: jest.fn(),
-};
diff --git a/src/components/__tests__/container.test.js b/src/components/__tests__/container.test.js
index e5f4a47..3b3fc08 100644
--- a/src/components/__tests__/container.test.js
+++ b/src/components/__tests__/container.test.js
@@ -12,6 +12,7 @@ import { createSubscriber } from '../subscriber';
 const mockLocalRegistry = {
   configure: jest.fn(),
   getStore: jest.fn(),
+  hasStore: jest.fn(),
   deleteStore: jest.fn(),
 };
 
@@ -21,6 +22,7 @@ jest.mock('../../store/registry', () => ({
   defaultRegistry: {
     configure: jest.fn(),
     getStore: jest.fn(),
+    hasStore: jest.fn(),
     deleteStore: jest.fn(),
   },
 }));
diff --git a/src/components/__tests__/integration.test.js b/src/components/__tests__/integration.test.js
index 0d04ca7..ab1e855 100644
--- a/src/components/__tests__/integration.test.js
+++ b/src/components/__tests__/integration.test.js
@@ -6,7 +6,7 @@ import { render } from '@testing-library/react';
 import { act } from 'react-dom/test-utils';
 
 import { createStore, defaultRegistry } from '../../store';
-import { createContainer } from '../container';
+import { createContainer, createDynamicContainer } from '../container';
 import { createSubscriber } from '../subscriber';
 import { createHook } from '../hook';
 
@@ -32,6 +32,7 @@ const actions = {
     },
 };
 const Store = createStore({
+  name: 'store',
   initialState: { todos: [], loading: false },
   actions,
 });
@@ -180,8 +181,8 @@ describe('Integration', () => {
 
     const state3 = { loading: false, todos: ['todoB'] };
     const call3 = 3;
-    // its 3+1 because on scope change we force notify to make sure memo components update too,
-    // causing ones that have naturally re-rendered already to re-render once more :(
+    // its 3+1 because on scope change we do NOT use context and force notify
+    // causing ones that have naturally re-rendered already to re-render once more.
     expect(children1.mock.calls[call3 + 1]).toEqual([state3, expectActions]);
     expect(children2.mock.calls[call3]).toEqual([state3, expectActions]);
   });
@@ -405,4 +406,63 @@ describe('Integration', () => {
 
     expect(selector).toHaveBeenCalledTimes(2);
   });
+
+  it('should capture all matched stores', async () => {
+    const matcher = jest.fn().mockReturnValue(true);
+    const onStoreInit = jest.fn().mockReturnValue(() => {});
+    const onStoreUpdate = jest.fn().mockReturnValue(() => {});
+    const onStoreCleanup = jest.fn().mockReturnValue(() => {});
+    const onPropsUpdate = jest.fn().mockReturnValue(() => {});
+    const DynContainer = createDynamicContainer({
+      matcher,
+      onStoreInit,
+      onStoreUpdate,
+      onStoreCleanup,
+      onPropsUpdate,
+    });
+    const NoopContainer = createDynamicContainer({
+      matcher: () => false,
+    });
+    const Subscriber = createSubscriber(Store);
+    const Store2 = createStore({ name: 'two', initialState: {}, actions });
+    const Subscriber2 = createSubscriber(Store2);
+
+    let acts;
+
+    const App = ({ value }) => (
+      <DynContainer value={value}>
+        <NoopContainer>
+          <Subscriber>{(_, a) => ((acts = a), null)}</Subscriber>
+          <Subscriber2>{() => null}</Subscriber2>
+        </NoopContainer>
+      </DynContainer>
+    );
+
+    const { rerender, unmount } = render(<App value="1" />);
+
+    expect(matcher).toHaveBeenCalledTimes(2);
+    expect(onStoreInit).toHaveBeenCalledTimes(2);
+    expect(onStoreInit.mock.calls[0]).toEqual([Store]);
+    expect(onStoreInit.mock.calls[1]).toEqual([Store2]);
+    expect(defaultRegistry.stores.size).toEqual(0);
+
+    act(() => acts.add('todo2'));
+
+    expect(onStoreUpdate).toHaveBeenCalledTimes(1);
+    expect(onStoreUpdate.mock.calls[0]).toEqual([Store]);
+
+    rerender(<App value="2" />);
+
+    expect(onPropsUpdate).toHaveBeenCalledTimes(2);
+    expect(onPropsUpdate.mock.calls[0]).toEqual([Store]);
+    expect(onPropsUpdate.mock.calls[1]).toEqual([Store2]);
+
+    unmount();
+
+    await actTick();
+
+    expect(onStoreCleanup).toHaveBeenCalledTimes(2);
+    expect(onStoreCleanup.mock.calls[0]).toEqual([Store]);
+    expect(onStoreCleanup.mock.calls[1]).toEqual([Store2]);
+  });
 });
diff --git a/src/components/container.js b/src/components/container.js
index 7d57999..8411b6c 100644
--- a/src/components/container.js
+++ b/src/components/container.js
@@ -1,4 +1,11 @@
-import React, { Component } from 'react';
+import React, {
+  Component,
+  useCallback,
+  useContext,
+  useMemo,
+  useRef,
+  useEffect,
+} from 'react';
 import PropTypes from 'prop-types';
 
 import { Context } from '../context';
@@ -188,4 +195,154 @@ export function createContainer(
       displayName || `Container(${Store.key.split('__')[0]})`;
     static hooks = { onInit, onUpdate, onCleanup };
   };
+
+  // eslint-disable-next-line no-unreachable
+  return createDynamicContainer({
+    matcher: (s) => s === Store,
+    onStoreInit: onInit,
+    onStoreCleanup: onCleanup,
+    onPropsUpdate: onUpdate,
+    displayName: displayName || `Container(${Store.key.split('__')[0]})`,
+  });
+}
+
+function useRegistry(scope, isGlobal, { globalRegistry }) {
+  return useMemo(() => {
+    const isLocal = !scope && !isGlobal;
+    return isLocal ? new StoreRegistry('__local__') : globalRegistry;
+  }, [scope, isGlobal, globalRegistry]);
+}
+
+function useContainedStore(scope, registry, hookActions, restProps) {
+  // Store contained scopes in a map, but throwing it away on scope change
+  // eslint-disable-next-line react-hooks/exhaustive-deps
+  const containedStores = useMemo(() => new Map(), [scope]);
+
+  // Store props in a ref to avoid re-binding actions when they change
+  // If devs want to update consumers on prop change, they can put them in store
+  const containerProps = useRef();
+  containerProps.current = restProps;
+
+  const getContainedStore = useCallback(
+    (Store) => {
+      let containedStore = containedStores.get(Store);
+      // first time it gets called we add store to contained map bound
+      // so we can provide props to actions (only triggered by children)
+      if (!containedStore) {
+        const isExisting = registry.hasStore(Store, scope);
+        const { storeState } = registry.getStore(Store, scope);
+        const getProps = () => containerProps.current;
+        const actions = bindActions(Store.actions, storeState, getProps);
+        const hooks = bindActions(hookActions, storeState, getProps, actions);
+        containedStore = {
+          storeState,
+          actions,
+          hooks,
+          unsubscribe: storeState.subscribe(() => hooks.onStoreUpdate(Store)),
+        };
+        containedStores.set(Store, containedStore);
+        // signal store is contained and ready now, so by the time
+        // consumers subscribe we already have updated the store (if needed)
+        if (!isExisting) hooks.onStoreInit(Store);
+      }
+      return containedStore;
+    },
+    [scope, containedStores, registry, hookActions]
+  );
+  return [containedStores, getContainedStore];
+}
+
+function useApi(memoMatcher, getContainedStore, { globalRegistry, getStore }) {
+  const getStoreRef = useRef();
+  getStoreRef.current = (Store) =>
+    memoMatcher(Store) ? getContainedStore(Store) : getStore(Store);
+
+  // This api is "frozen", as changing it will trigger re-render across all consumers
+  // so we link getStore dynamically and manually call notify() on scope change
+  return useMemo(
+    () => ({ globalRegistry, getStore: (s) => getStoreRef.current(s) }),
+    [globalRegistry]
+  );
+}
+
+export function createDynamicContainer({
+  matcher,
+  onStoreInit = noop,
+  onStoreUpdate = noop,
+  onStoreCleanup = noop,
+  onPropsUpdate = noop,
+  displayName = '',
+}) {
+  const hookActions = {
+    onStoreInit,
+    onStoreUpdate,
+    onStoreCleanup,
+    onPropsUpdate,
+  };
+
+  const memoMatcher = ((cache) => (Store) => {
+    if (!cache.has(Store)) cache.set(Store, matcher(Store));
+    return cache.get(Store);
+  })(new WeakMap());
+
+  function DynamicContainer({ children, scope, isGlobal, ...restProps }) {
+    const ctx = useContext(Context);
+    const registry = useRegistry(scope, isGlobal, ctx);
+    const [containedStores, getContainedStore] = useContainedStore(
+      scope,
+      registry,
+      hookActions,
+      restProps
+    );
+    const api = useApi(memoMatcher, getContainedStore, ctx);
+
+    // This listens for custom props change, and so we trigger container update actions
+    // before the re-render gets to consumers, hence why memo and not effect
+    useMemo(() => {
+      containedStores.forEach(({ hooks }, Store) => {
+        hooks.onPropsUpdate(Store);
+      });
+      // Deps are dynamic because we want to notify on any custom prop change
+      // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, Object.values(restProps).concat(containedStores));
+
+    // This listens for scope change or component unmount, to notify all consumers
+    // so all work is done on cleanup
+    useEffect(() => {
+      const cachedScope = scope;
+      return () => {
+        containedStores.forEach(({ storeState, hooks, unsubscribe }, Store) => {
+          // Detatch container from subscription
+          unsubscribe();
+          // Trigger a forced update on all subscribers as we opted out from context
+          // Some might have already re-rendered naturally, but we "force update" all anyway.
+          // This is sub-optimal as if there are other containers with the same
+          // old scope id we will re-render those too, but still better than context
+          storeState.notify();
+          // Schedule check if instance has still subscribers, if not delete
+          Promise.resolve().then(() => {
+            if (
+              !storeState.listeners().length &&
+              // ensure registry has not already created a new store with same scope
+              storeState === registry.getStore(Store, cachedScope).storeState
+            ) {
+              hooks.onStoreCleanup(Store);
+              registry.deleteStore(Store, cachedScope);
+            }
+          });
+        });
+      };
+    }, [registry, scope, containedStores]);
+
+    return <Context.Provider value={api}>{children}</Context.Provider>;
+  }
+
+  DynamicContainer.displayName = displayName || `DynamicContainer`;
+  DynamicContainer.propTypes = {
+    children: PropTypes.node,
+    scope: PropTypes.string,
+    isGlobal: PropTypes.bool,
+  };
+
+  return DynamicContainer;
 }
diff --git a/src/index.js b/src/index.js
index 72e7558..dc4d721 100644
--- a/src/index.js
+++ b/src/index.js
@@ -1,6 +1,9 @@
 // @flow
 
-export { createContainer } from './components/container';
+export {
+  createContainer,
+  createDynamicContainer,
+} from './components/container';
 export { createSubscriber } from './components/subscriber';
 export {
   createHook,
diff --git a/src/index.js.flow b/src/index.js.flow
index cb0af44..9bff483 100644
--- a/src/index.js.flow
+++ b/src/index.js.flow
@@ -145,6 +145,19 @@ declare export function createContainer<ST, AC, CPR>(
   |}
 ): ContainerComponent<CPR>;
 
+/**
+ * createContainer
+ */
+
+declare export function createDynamicContainer<CPR>(config: {|
+  matcher: (store: Store<any, any>) => boolean,
+  onStoreInit?: (store: Store<any, any>) => Action<any, CPR>,
+  onStoreUpdate?: (store: Store<any, any>) => Action<any, CPR>,
+  onStoreCleanup?: (store: Store<any, any>) => Action<any, CPR>,
+  onPropsUpdate?: (store: Store<any, any>) => Action<any, CPR>,
+  displayName?: string,
+|}): ContainerComponent<CPR>;
+
 /**
  * createSubscriber
  */
diff --git a/src/store/__tests__/create-state.test.js b/src/store/__tests__/create-state.test.js
index 572a674..323b02b 100644
--- a/src/store/__tests__/create-state.test.js
+++ b/src/store/__tests__/create-state.test.js
@@ -3,13 +3,13 @@
 import { storeStateMock } from '../../__tests__/mocks';
 import defaults from '../../defaults';
 import supports from '../../utils/supported-features';
-import createStore from '../create-state';
+import createStoreState from '../create-state';
 
 const initialState = { count: 0 };
 
-describe('createStore', () => {
+describe('createStoreState', () => {
   it('should return a store object', () => {
-    const store = createStore(storeStateMock.key, initialState);
+    const store = createStoreState(storeStateMock.key, initialState);
     expect(store).toEqual({
       key: storeStateMock.key,
       getState: expect.any(Function),
@@ -24,21 +24,21 @@ describe('createStore', () => {
 
   describe('getState()', () => {
     it('should return current state', () => {
-      const store = createStore(storeStateMock.key, initialState);
+      const store = createStoreState(storeStateMock.key, initialState);
       expect(store.getState()).toBe(initialState);
     });
   });
 
   describe('setState()', () => {
     it('should replace current state', () => {
-      const store = createStore(storeStateMock.key, initialState);
+      const store = createStoreState(storeStateMock.key, initialState);
       const newState = { count: 1 };
       store.setState(newState);
       expect(store.getState()).toBe(newState);
     });
 
     it('should notify listeners when multiple calls', () => {
-      const store = createStore(storeStateMock.key, initialState);
+      const store = createStoreState(storeStateMock.key, initialState);
       const listener = jest.fn();
       store.subscribe(listener);
       store.setState({ count: 1 });
@@ -53,7 +53,7 @@ describe('createStore', () => {
         .mockReturnValue(true);
       defaults.batchUpdates = true;
 
-      const store = createStore(storeStateMock.key, initialState);
+      const store = createStoreState(storeStateMock.key, initialState);
       const listener = jest.fn();
       store.subscribe(listener);
 
@@ -71,7 +71,7 @@ describe('createStore', () => {
 
   describe('resetState()', () => {
     it('should replace current state with initial state', async () => {
-      const store = createStore(storeStateMock.key, initialState);
+      const store = createStoreState(storeStateMock.key, initialState);
       store.setState({ count: 1 });
       const listener = jest.fn();
       store.subscribe(listener);
@@ -82,7 +82,7 @@ describe('createStore', () => {
 
   describe('notify()', () => {
     it('should notify listeners', () => {
-      const store = createStore(storeStateMock.key, initialState);
+      const store = createStoreState(storeStateMock.key, initialState);
       const listener = jest.fn();
       store.subscribe(listener);
       store.notify();
@@ -92,7 +92,7 @@ describe('createStore', () => {
 
   describe('unsubscribe()', () => {
     it('should remove listener', () => {
-      const store = createStore(storeStateMock.key, initialState);
+      const store = createStoreState(storeStateMock.key, initialState);
       const newState = { count: 1 };
       const listener = jest.fn();
       const unsubscribe = store.subscribe(listener);
@@ -104,7 +104,7 @@ describe('createStore', () => {
 
   describe('mutator()', () => {
     it('should modify state', () => {
-      const store = createStore(storeStateMock.key, initialState);
+      const store = createStoreState(storeStateMock.key, initialState);
       store.mutator({
         count: 1,
       });
diff --git a/src/store/__tests__/registry.test.js b/src/store/__tests__/registry.test.js
index bd78ea4..fe9d802 100644
--- a/src/store/__tests__/registry.test.js
+++ b/src/store/__tests__/registry.test.js
@@ -20,6 +20,13 @@ describe('StoreRegistry', () => {
     expect(instance.storeState.getState()).toEqual({ count: 0 });
   });
 
+  it('should say if store exists already', () => {
+    const registry = new StoreRegistry();
+    expect(registry.hasStore(StoreMock, 's1')).toBe(false);
+    registry.getStore(StoreMock, 's1');
+    expect(registry.hasStore(StoreMock, 's1')).toBe(true);
+  });
+
   it('should get an existing store if no scopeId provided', () => {
     const registry = new StoreRegistry();
     const instance1 = registry.getStore(StoreMock);
diff --git a/src/store/create.js b/src/store/create.js
index 303d477..61b939c 100644
--- a/src/store/create.js
+++ b/src/store/create.js
@@ -9,14 +9,16 @@ function createKey(initialState, actions, name) {
     .join('__');
 }
 
-export function createStore({ name = '', initialState, actions }) {
+export function createStore({ name = '', initialState, actions, tags }) {
   let key;
   return {
+    name,
     get key() {
       // lazy evaluate key on first access
       return key || (key = createKey(initialState, actions, name));
     },
     initialState,
     actions,
+    tags,
   };
 }
diff --git a/src/store/registry.js b/src/store/registry.js
index 49e7ad3..ba1c7c3 100644
--- a/src/store/registry.js
+++ b/src/store/registry.js
@@ -20,6 +20,11 @@ export class StoreRegistry {
     return store;
   };
 
+  hasStore = (Store, scopeId = this.defaultScope) => {
+    const key = this.generateKey(Store, scopeId);
+    return this.stores.has(key);
+  };
+
   getStore = (Store, scopeId = this.defaultScope) => {
     const key = this.generateKey(Store, scopeId);
     return this.stores.get(key) || this.initStore(key, Store);
diff --git a/types/index.d.ts b/types/index.d.ts
index 8eb25aa..3fcaf95 100644
--- a/types/index.d.ts
+++ b/types/index.d.ts
@@ -24,9 +24,11 @@ declare module 'react-sweet-state' {
     TState,
     TActions extends Record<string, ActionThunk<TState, TActions>>
   > = {
+    name?: string;
     key: string;
     initialState: TState;
     actions: TActions;
+    tags?: string[];
   };
 
   type StoreState<TState> = {
@@ -89,6 +91,13 @@ declare module 'react-sweet-state' {
       store: Store<TState, TActions>,
       scopeId?: string
     ) => StoreInstance<TState, TActions>;
+    hasStore: <
+      TState,
+      TActions extends Record<string, ActionThunk<TState, TActions>>
+    >(
+      store: Store<TState, TActions>,
+      scopeId?: string
+    ) => boolean;
     deleteStore: <
       TState,
       TActions extends Record<string, ActionThunk<TState, TActions>>
@@ -160,6 +169,7 @@ declare module 'react-sweet-state' {
     initialState: TState;
     actions: TActions;
     name?: string;
+    tags?: string[];
   }): Store<TState, TActions>;
 
   /**
@@ -180,6 +190,30 @@ declare module 'react-sweet-state' {
     }
   ): ContainerComponent<TContainerProps>;
 
+  /**
+   * createDynamicContainer
+   */
+
+  function createDynamicContainer<
+    TStoreType extends Store<unknown, Record<string, any>>,
+    TContainerProps = unknown
+  >(config: {
+    matcher: (store: TStoreType) => boolean;
+    onStoreInit?: (
+      store: TStoreType
+    ) => Action<TStoreType['initialState'], TContainerProps>;
+    onStoreUpdate?: (
+      store: TStoreType
+    ) => Action<TStoreType['initialState'], TContainerProps>;
+    onStoreCleanup?: (
+      store: TStoreType
+    ) => Action<TStoreType['initialState'], TContainerProps>;
+    onPropsUpdate?: (
+      store: TStoreType
+    ) => Action<TStoreType['initialState'], TContainerProps>;
+    displayName?: string;
+  }): ContainerComponent<TContainerProps>;
+
   /**
    * createSubscriber
    */
diff --git a/types/test.tsx b/types/test.tsx
index cc9d92c..a53a128 100644
--- a/types/test.tsx
+++ b/types/test.tsx
@@ -11,6 +11,7 @@ import {
   createStateHook,
   StoreActionApi,
   Action,
+  createDynamicContainer,
 } from 'react-sweet-state';
 
 /**
@@ -149,19 +150,19 @@ const actions = {
 };
 
 // @ts-expect-error
-const TypeStore0 = createStore<State, Actions>({ count: 0 });
+createStore<State, Actions>({ count: 0 });
 
-const TypeStore1 = createStore<State, Actions>({
+createStore<State, Actions>({
   // @ts-expect-error
   initialState: { bla: 0 },
   actions,
 });
 
 // @ts-expect-error
-const TypeStore2 = createStore<State, Actions>({ initialState: { count: 0 } });
+createStore<State, Actions>({ initialState: { count: 0 } });
 
 // @ts-expect-error
-const TypeStore3 = createStore<string, Actions>({ initialState: '', actions });
+createStore<string, Actions>({ initialState: '', actions });
 
 // Correct
 const TypeStore = createStore<State, Actions>({
@@ -441,3 +442,74 @@ Test = (
     bla
   </TypePropsContainer>
 );
+
+/**
+ * Dynamic Container types tests
+ */
+
+const TypeDynContainer = createDynamicContainer({
+  matcher: (s) => s.tags?.includes('bla') ?? false,
+  onStoreInit:
+    (s) =>
+    ({ getState, setState }) => {
+      // @ts-expect-error
+      getState().count;
+      // untyped
+      setState({ value: 1 });
+    },
+});
+
+Test = (
+  // @ts-expect-error
+  <TypeDynContainer>{({ count }) => count}</TypeDynContainer>
+);
+
+Test = (
+  // @ts-expect-error
+  <TypeDynContainer foo="1">bla</TypeDynContainer>
+);
+
+// Correct
+Test = <TypeDynContainer>bla</TypeDynContainer>;
+Test = <TypeDynContainer scope="a">bla</TypeDynContainer>;
+Test = <TypeDynContainer isGlobal>bla</TypeDynContainer>;
+
+const TypeStore2 = createStore<{ value: string }, Record<string, never>>({
+  initialState: { value: '' },
+  actions: {},
+});
+
+const TypePropsDynContainer = createDynamicContainer<
+  typeof TypeStore | typeof TypeStore2,
+  { url: string }
+>({
+  matcher: (s) => s.tags?.includes('bla') ?? false,
+  onStoreUpdate:
+    (s) =>
+    ({ getState, setState }) => {
+      const state = getState();
+      if ('count' in state) {
+        setState({ count: state.count + 1 });
+        // @ts-expect-error
+        setState({ value });
+      }
+      if ('value' in state) {
+        setState({ value: state.value.replace('', '') });
+      }
+    },
+});
+
+// @ts-expect-error
+Test = <TypePropsDynContainer isGlobal>bla</TypePropsDynContainer>;
+
+Test = (
+  // @ts-expect-error
+  <TypePropsDynContainer foo="1">bla</TypePropsDynContainer>
+);
+
+// Correct
+Test = (
+  <TypePropsDynContainer scope="a" url="">
+    bla
+  </TypePropsDynContainer>
+);