diff --git a/packages/di/di.tsx b/packages/di/di.tsx
index d78691a8..2a52dfcd 100644
--- a/packages/di/di.tsx
+++ b/packages/di/di.tsx
@@ -1,4 +1,11 @@
-import React, { StatelessComponent, ComponentType, createContext } from 'react';
+import React, {
+    ReactNode,
+    FunctionComponent,
+    StatelessComponent,
+    ComponentType,
+    createContext,
+    useContext,
+} from 'react';
 
 export type GetNonDefaultProps<T> = keyof T extends never ? never : T;
 export type RegistryContext = Record<string, Registry>;
@@ -40,12 +47,12 @@ export function withRegistry(...registries: Registry[]) {
     };
 }
 
-export interface IComponentRegistryConsumer {
+export interface IComponentRegistryConsumerProps {
     id: string;
-    children: (registry: any) => React.ReactNode;
+    children: (registry: any) => ReactNode;
 }
 
-export const ComponentRegistryConsumer: React.SFC<IComponentRegistryConsumer> = props => (
+export const ComponentRegistryConsumer: FunctionComponent<IComponentRegistryConsumerProps> = props => (
     <RegistryConsumer>
         {registries => {
             if (__DEV__) {
@@ -59,6 +66,16 @@ export const ComponentRegistryConsumer: React.SFC<IComponentRegistryConsumer> =
     </RegistryConsumer>
 );
 
+export const useRegistries = () => {
+    return useContext(registryContext);
+};
+
+export const useComponentRegistry = <T extends {}>(id: string) => {
+    const registries = useRegistries();
+
+    return registries[id].snapshot<T>();
+};
+
 export interface IRegistryOptions {
     id: string;
     inverted?: boolean;
diff --git a/packages/di/package.json b/packages/di/package.json
index cf3a8f39..ac1cf426 100644
--- a/packages/di/package.json
+++ b/packages/di/package.json
@@ -30,7 +30,7 @@
     "test": "../../node_modules/.bin/nyc npm run unit test/*.test.tsx"
   },
   "peerDependencies": {
-    "react": "^16.0.0"
+    "react": "^16.8.0"
   },
   "nyc": {
     "include": [
diff --git a/packages/di/test/di.test.tsx b/packages/di/test/di.test.tsx
index c8718143..a7b016b9 100644
--- a/packages/di/test/di.test.tsx
+++ b/packages/di/test/di.test.tsx
@@ -4,7 +4,14 @@ import { describe, it } from 'mocha';
 import { expect } from 'chai';
 import { render } from 'enzyme';
 
-import { Registry, withRegistry, RegistryConsumer, ComponentRegistryConsumer } from '../di';
+import {
+    Registry,
+    withRegistry,
+    RegistryConsumer,
+    ComponentRegistryConsumer,
+    useRegistries,
+    useComponentRegistry,
+} from '../di';
 
 interface ICommonProps {
     className?: string;
@@ -90,204 +97,252 @@ describe('@bem-react/di', () => {
     });
 
     describe('withRegistry', () => {
-        it('should provide registry to context', () => {
-            const compositorRegistry = new Registry({ id: 'Compositor' });
-            const Element: React.SFC<ICommonProps> = () => <span>content</span>;
+        describe('consumer', () => {
+            it('should provide registry to context', () => {
+                const compositorRegistry = new Registry({ id: 'Compositor' });
+                const Element: React.SFC<ICommonProps> = () => <span>content</span>;
 
-            interface ICompositorRegistry {
-                Element: React.ComponentType<ICommonProps>;
-            }
+                interface ICompositorRegistry {
+                    Element: React.ComponentType<ICommonProps>;
+                }
 
-            compositorRegistry.set('Element', Element);
+                compositorRegistry.set('Element', Element);
 
-            const CompositorPresenter: React.SFC<ICommonProps> = () => (
-                <RegistryConsumer>
-                    {registries => {
-                        const registry = registries['Compositor'];
-                        const { Element } = registry.snapshot<ICompositorRegistry>();
+                const CompositorPresenter: React.SFC<ICommonProps> = () => (
+                    <RegistryConsumer>
+                        {registries => {
+                            const registry = registries['Compositor'];
+                            const { Element } = registry.snapshot<ICompositorRegistry>();
 
-                        return <Element/>;
-                    }}
-                </RegistryConsumer>
-            );
+                            return <Element/>;
+                        }}
+                    </RegistryConsumer>
+                );
 
-            const Compositor = withRegistry(compositorRegistry)(CompositorPresenter);
+                const Compositor = withRegistry(compositorRegistry)(CompositorPresenter);
 
-            expect(render(<Compositor/>).text()).eq('content');
-        });
+                expect(render(<Compositor/>).text()).eq('content');
+            });
+
+            it('should provide assign registry with component', () => {
+                const compositorRegistry = new Registry({ id: 'Compositor' });
+                const Element: React.SFC<ICommonProps> = () => <span>content</span>;
 
-        it('should provide assign registry with component', () => {
-            const compositorRegistry = new Registry({ id: 'Compositor' });
-            const Element: React.SFC<ICommonProps> = () => <span>content</span>;
+                interface ICompositorRegistry {
+                    Element: React.ComponentType<ICommonProps>;
+                }
 
-            interface ICompositorRegistry {
-                Element: React.ComponentType<ICommonProps>;
-            }
+                compositorRegistry.set('Element', Element);
 
-            compositorRegistry.set('Element', Element);
+                const CompositorPresenter: React.SFC<ICommonProps> = () => (
+                    <ComponentRegistryConsumer id="Compositor">
+                        {({ Element }: ICompositorRegistry) => <Element/>}
+                    </ComponentRegistryConsumer>
+                );
 
-            const CompositorPresenter: React.SFC<ICommonProps> = () => (
-                <ComponentRegistryConsumer id="Compositor">
-                    {({ Element }: ICompositorRegistry) => <Element/>}
-                </ComponentRegistryConsumer>
-            );
+                const Compositor = withRegistry(compositorRegistry)(CompositorPresenter);
 
-            const Compositor = withRegistry(compositorRegistry)(CompositorPresenter);
+                expect(render(<Compositor/>).text()).eq('content');
+            });
 
-            expect(render(<Compositor/>).text()).eq('content');
-        });
+            it('should override components in registry by context', () => {
+                const compositorRegistry = new Registry({ id: 'Compositor' });
+                const Element: React.SFC<ICommonProps> = () => <span>content</span>;
+
+                const overridedCompositorRegistry = new Registry({ id: 'Compositor' });
+                const OverridedElement: React.SFC<ICommonProps> = () => <span>overrided</span>;
+
+                interface ICompositorRegistry {
+                    Element: React.ComponentType<ICommonProps>;
+                }
+
+                compositorRegistry.set('Element', Element);
+                overridedCompositorRegistry.set('Element', OverridedElement);
+
+                const CompositorPresenter: React.SFC<ICommonProps> = () => {
+                    const Content: React.SFC<ICommonProps> = withRegistry(overridedCompositorRegistry)(() => (
+                        <ComponentRegistryConsumer id="Compositor">
+                            {({ Element }: ICompositorRegistry) => <Element/>}
+                        </ComponentRegistryConsumer>
+                    ));
+
+                    return <Content/>;
+                };
 
-        it('should override components in registry by context', () => {
-            const compositorRegistry = new Registry({ id: 'Compositor' });
-            const Element: React.SFC<ICommonProps> = () => <span>content</span>;
+                const Compositor = withRegistry(compositorRegistry)(CompositorPresenter);
 
-            const overridedCompositorRegistry = new Registry({ id: 'Compositor' });
-            const OverridedElement: React.SFC<ICommonProps> = () => <span>overrided</span>;
+                expect(render(<Compositor/>).text()).eq('overrided');
+            });
 
-            interface ICompositorRegistry {
-                Element: React.ComponentType<ICommonProps>;
-            }
+            it('should override components in registry from top node', () => {
+                const compositorRegistry = new Registry({ id: 'Compositor', inverted: true });
+                const Element: React.SFC<ICommonProps> = () => <span>content</span>;
 
-            compositorRegistry.set('Element', Element);
-            overridedCompositorRegistry.set('Element', OverridedElement);
+                const overridedCompositorRegistry = new Registry({ id: 'Compositor' });
+                const OverridedElement: React.SFC<ICommonProps> = () => <span>overrided</span>;
 
-            const CompositorPresenter: React.SFC<ICommonProps> = () => {
-                const Content: React.SFC<ICommonProps> = withRegistry(overridedCompositorRegistry)(() => (
+                interface ICompositorRegistry {
+                    Element: React.ComponentType<ICommonProps>;
+                }
+
+                compositorRegistry.set('Element', Element);
+                overridedCompositorRegistry.set('Element', OverridedElement);
+
+                const CompositorPresenter: React.SFC<ICommonProps> = () => (
                     <ComponentRegistryConsumer id="Compositor">
                         {({ Element }: ICompositorRegistry) => <Element/>}
                     </ComponentRegistryConsumer>
-                ));
+                );
 
-                return <Content/>;
-            };
+                const Compositor = withRegistry(compositorRegistry)(CompositorPresenter);
+                const OverridedCompositor = withRegistry(overridedCompositorRegistry)(Compositor);
 
-            const Compositor = withRegistry(compositorRegistry)(CompositorPresenter);
+                expect(render(<Compositor/>).text()).eq('content');
+                expect(render(<OverridedCompositor/>).text()).eq('overrided');
+            });
 
-            expect(render(<Compositor/>).text()).eq('overrided');
-        });
+            it('should partially override components in registry', () => {
+                const compositorRegistry = new Registry({ id: 'Compositor', inverted: true });
+                const Element1: React.SFC<ICommonProps> = () => <span>content</span>;
+                const Element2: React.SFC<ICommonProps> = () => <span>extra</span>;
 
-        it('should override components in registry from top node', () => {
-            const compositorRegistry = new Registry({ id: 'Compositor', inverted: true });
-            const Element: React.SFC<ICommonProps> = () => <span>content</span>;
+                const overridedCompositorRegistry = new Registry({ id: 'Compositor' });
+                const OverridedElement: React.SFC<ICommonProps> = () => <span>overrided</span>;
 
-            const overridedCompositorRegistry = new Registry({ id: 'Compositor' });
-            const OverridedElement: React.SFC<ICommonProps> = () => <span>overrided</span>;
+                interface ICompositorRegistry {
+                    Element1: React.ComponentType<ICommonProps>;
+                    Element2: React.ComponentType<ICommonProps>;
+                }
 
-            interface ICompositorRegistry {
-                Element: React.ComponentType<ICommonProps>;
-            }
+                compositorRegistry.set('Element1', Element1);
+                compositorRegistry.set('Element2', Element2);
+                overridedCompositorRegistry.set('Element1', OverridedElement);
 
-            compositorRegistry.set('Element', Element);
-            overridedCompositorRegistry.set('Element', OverridedElement);
+                const CompositorPresenter: React.SFC<ICommonProps> = () => (
+                    <ComponentRegistryConsumer id="Compositor">
+                        {({ Element1, Element2 }: ICompositorRegistry) => (
+                            <>
+                                <Element1/>
+                                <Element2/>
+                            </>
+                        )}
+                    </ComponentRegistryConsumer>
+                );
 
-            const CompositorPresenter: React.SFC<ICommonProps> = () => (
-                <ComponentRegistryConsumer id="Compositor">
-                    {({ Element }: ICompositorRegistry) => <Element/>}
-                </ComponentRegistryConsumer>
-            );
+                const Compositor = withRegistry(compositorRegistry)(CompositorPresenter);
+                const OverridedCompositor = withRegistry(overridedCompositorRegistry)(Compositor);
 
-            const Compositor = withRegistry(compositorRegistry)(CompositorPresenter);
-            const OverridedCompositor = withRegistry(overridedCompositorRegistry)(Compositor);
+                expect(render(<OverridedCompositor/>).text()).eq('overridedextra');
+                expect(render(<Compositor/>).text()).eq('contentextra');
+            });
 
-            expect(render(<Compositor/>).text()).eq('content');
-            expect(render(<OverridedCompositor/>).text()).eq('overrided');
-        });
+            it('should allow to use any registry in context', () => {
+                const compositorRegistry = new Registry({ id: 'Compositor', inverted: true });
+                const element2Registry = new Registry({ id: 'Element2', inverted: true });
+                const Element1: React.SFC<ICommonProps> = () => <span>content</span>;
+                const Element2Presenter: React.SFC<ICommonProps> = () => (
+                    <ComponentRegistryConsumer id="Compositor">
+                        {({ Element }: ICompositorRegistry) => <><Element/>extra</>}
+                    </ComponentRegistryConsumer>
+                );
+                const Element2 = withRegistry(element2Registry)(Element2Presenter);
 
-        it('should partially override components in registry', () => {
-            const compositorRegistry = new Registry({ id: 'Compositor', inverted: true });
-            const Element1: React.SFC<ICommonProps> = () => <span>content</span>;
-            const Element2: React.SFC<ICommonProps> = () => <span>extra</span>;
-
-            const overridedCompositorRegistry = new Registry({ id: 'Compositor' });
-            const OverridedElement: React.SFC<ICommonProps> = () => <span>overrided</span>;
-
-            interface ICompositorRegistry {
-                Element1: React.ComponentType<ICommonProps>;
-                Element2: React.ComponentType<ICommonProps>;
-            }
-
-            compositorRegistry.set('Element1', Element1);
-            compositorRegistry.set('Element2', Element2);
-            overridedCompositorRegistry.set('Element1', OverridedElement);
-
-            const CompositorPresenter: React.SFC<ICommonProps> = () => (
-                <ComponentRegistryConsumer id="Compositor">
-                    {({ Element1, Element2 }: ICompositorRegistry) => (
-                        <>
-                            <Element1/>
-                            <Element2/>
-                        </>
-                    )}
-                </ComponentRegistryConsumer>
-            );
-
-            const Compositor = withRegistry(compositorRegistry)(CompositorPresenter);
-            const OverridedCompositor = withRegistry(overridedCompositorRegistry)(Compositor);
-
-            expect(render(<OverridedCompositor/>).text()).eq('overridedextra');
-            expect(render(<Compositor/>).text()).eq('contentextra');
-        });
+                interface ICompositorRegistry {
+                    Element: React.ComponentType<ICommonProps>;
+                    Element2: React.ComponentType<ICommonProps>;
+                }
 
-        it('should allow to use any registry in context', () => {
-            const compositorRegistry = new Registry({ id: 'Compositor', inverted: true });
-            const element2Registry = new Registry({ id: 'Element2', inverted: true });
-            const Element1: React.SFC<ICommonProps> = () => <span>content</span>;
-            const Element2Presenter: React.SFC<ICommonProps> = () => (
-                <ComponentRegistryConsumer id="Compositor">
-                    {({ Element }: ICompositorRegistry) => <><Element/>extra</>}
-                </ComponentRegistryConsumer>
-            );
-            const Element2 = withRegistry(element2Registry)(Element2Presenter);
-
-            interface ICompositorRegistry {
-                Element: React.ComponentType<ICommonProps>;
-                Element2: React.ComponentType<ICommonProps>;
-            }
-
-            compositorRegistry.set('Element', Element1);
-            compositorRegistry.set('Element2', Element2);
-
-            const CompositorPresenter: React.SFC<ICommonProps> = () => (
-                <ComponentRegistryConsumer id="Compositor">
-                    {({ Element2 }: ICompositorRegistry) => <Element2/>}
-                </ComponentRegistryConsumer>
-            );
-
-            const Compositor = withRegistry(compositorRegistry)(CompositorPresenter);
-
-            expect(render(<Compositor/>).text()).eq('contentextra');
+                compositorRegistry.set('Element', Element1);
+                compositorRegistry.set('Element2', Element2);
+
+                const CompositorPresenter: React.SFC<ICommonProps> = () => (
+                    <ComponentRegistryConsumer id="Compositor">
+                        {({ Element2 }: ICompositorRegistry) => <Element2/>}
+                    </ComponentRegistryConsumer>
+                );
+
+                const Compositor = withRegistry(compositorRegistry)(CompositorPresenter);
+
+                expect(render(<Compositor/>).text()).eq('contentextra');
+            });
+
+            it('should not influence adjacent context', () => {
+                const registry = new Registry({ id: 'RegistryParent' });
+                const registryA = new Registry({ id: 'TestRegistry' });
+                const registryB = new Registry({ id: 'TestRegistry' });
+                const elementA: React.SFC<ICommonProps> = () => <span>a</span>;
+                const elementB: React.SFC<ICommonProps> = () => <span>b</span>;
+
+                registryA.set('Element', elementA);
+                registryB.set('Element', elementB);
+
+                const ElementPresenter: React.SFC<ICommonProps> = () => (
+                    <ComponentRegistryConsumer id="TestRegistry">
+                        {({ Element }) => <Element/>}
+                    </ComponentRegistryConsumer>
+                );
+
+                const BranchA = withRegistry(registryA)(ElementPresenter);
+                const BranchB = withRegistry(registryB)(ElementPresenter);
+
+                const AppPresenter: React.SFC<ICommonProps> = () => (
+                    <>
+                        <BranchA/>
+                        <BranchB/>
+                        <BranchA/>
+                    </>
+                );
+
+                const App = withRegistry(registry)(AppPresenter);
+
+                expect(render(<App/>).text()).eq('aba');
+            });
         });
 
-        it('should not influence adjacent context', () => {
-            const registry = new Registry({ id: 'RegistryParent' });
-            const registryA = new Registry({ id: 'TestRegistry' });
-            const registryB = new Registry({ id: 'TestRegistry' });
-            const elementA: React.SFC<ICommonProps> = () => <span>a</span>;
-            const elementB: React.SFC<ICommonProps> = () => <span>b</span>;
+        describe('hooks', () => {
+            it('should provide registry with useRegistries', () => {
+                const compositorRegistry = new Registry({ id: 'Compositor' });
+                const Element = (props: ICommonProps) => <span>content</span>;
+
+                interface ICompositorRegistry {
+                    Element: typeof Element;
+                }
+
+                compositorRegistry.set('Element', Element);
+
+                const CompositorPresenter = (props: ICommonProps) => {
+                    const registries = useRegistries();
+                    const registry = registries['Compositor'];
+                    const { Element } = registry.snapshot<ICompositorRegistry>();
+
+                    return <Element />;
+                };
+
+                const Compositor = withRegistry(compositorRegistry)(CompositorPresenter);
+
+                expect(render(<Compositor/>).text()).eq('content');
+            });
+
+            it('should provide assign registry with useComponentRegistry', () => {
+                const compositorRegistry = new Registry({ id: 'Compositor' });
+                const Element = (props: ICommonProps) => <span>content</span>;
 
-            registryA.set('Element', elementA);
-            registryB.set('Element', elementB);
+                interface ICompositorRegistry {
+                    Element: typeof Element;
+                }
 
-            const ElementPresenter: React.SFC<ICommonProps> = () => (
-                <ComponentRegistryConsumer id="TestRegistry">
-                    {({ Element }) => <Element/>}
-                </ComponentRegistryConsumer>
-            );
+                compositorRegistry.set('Element', Element);
 
-            const BranchA = withRegistry(registryA)(ElementPresenter);
-            const BranchB = withRegistry(registryB)(ElementPresenter);
+                const CompositorPresenter = (props: ICommonProps) => {
+                    const { Element } = useComponentRegistry<ICompositorRegistry>('Compositor');
 
-            const AppPresenter: React.SFC<ICommonProps> = () => (
-                <>
-                    <BranchA/>
-                    <BranchB/>
-                    <BranchA/>
-                </>
-            );
+                    return <Element />;
+                };
 
-            const App = withRegistry(registry)(AppPresenter);
+                const Compositor = withRegistry(compositorRegistry)(CompositorPresenter);
 
-            expect(render(<App/>).text()).eq('aba');
+                expect(render(<Compositor/>).text()).eq('content');
+            });
         });
     });
 });