diff --git a/core/src/constants.ts b/core/src/constants.ts
index c47c00d8..9832aef0 100644
--- a/core/src/constants.ts
+++ b/core/src/constants.ts
@@ -38,6 +38,11 @@ export const EVENTS = {
     },
 } as const;
 
+export const MUTATIONS = {
+    snapshot: 'core:snapshot',
+    reset: 'core:reset',
+} as const;
+
 export const PROVIDERS = {
     read: value => value,
     write: value => value,
diff --git a/core/src/index.ts b/core/src/index.ts
index 73d75f4b..05af72f8 100644
--- a/core/src/index.ts
+++ b/core/src/index.ts
@@ -70,7 +70,7 @@ function emitCreated(store: InternalStore, state: any): void {
     eventEmitter.once(EVENTS.core.installed, created);
 }
 
-function getExtendedStore<TState extends BaseState, TExtensions extends Extension<TState>[]>(store: InternalStore, extensions: TExtensions): ReturnType<Extension<TState>> {
+function getExtendedStore<TState extends BaseState, TExtensions extends Extension<TState>[]>(store: InternalStore<TState>, extensions: TExtensions): ReturnType<Extension<TState>> {
     return extensions.reduce((output, extension) => {
         let result = {};
 
@@ -185,6 +185,8 @@ export function createStore<TState extends BaseState, TExtensions extends Extens
         getter: store.getter.bind(store),
         mutation: store.mutation.bind(store),
         action: store.action.bind(store),
+        snapshot: store.snapshot.bind(store),
+        reset: store.reset.bind(store),
         suppress: store.suppress.bind(store),
         on: store.on.bind(store),
         once: store.once.bind(store),
diff --git a/core/src/store.ts b/core/src/store.ts
index 9663bcce..61a87623 100644
--- a/core/src/store.ts
+++ b/core/src/store.ts
@@ -2,6 +2,8 @@ import eventEmitter from './event-emitter';
 
 import {
     EVENTS,
+    INTERNAL,
+    MUTATIONS,
     PROVIDERS,
     SENDER,
 } from './constants';
@@ -15,11 +17,18 @@ import {
     readonly,
 } from 'vue';
 
+import {
+    clone,
+    identity,
+    overwrite,
+} from '@harlem/utilities';
+
 import type {
     Action,
     ActionBody,
     ActionEventData,
     BaseState,
+    BranchAccessor,
     EventHandler,
     EventListener,
     EventPayload,
@@ -36,6 +45,7 @@ import type {
     StoreProviders,
     StoreRegistration,
     StoreRegistrations,
+    StoreSnapshot,
     WriteState,
 } from './types';
 
@@ -47,7 +57,7 @@ function localiseHandler(name: string, handler: EventHandler): EventHandler {
     };
 }
 
-export default class Store<TState extends BaseState = any> implements InternalStore<TState> {
+export default class Store<TState extends BaseState = BaseState> implements InternalStore<TState> {
 
     private options: InternalStoreOptions<TState>;
     private flags: Map<string, unknown>;
@@ -56,6 +66,7 @@ export default class Store<TState extends BaseState = any> implements InternalSt
     private isSuppressing: boolean;
     private readState: ReadState<TState>;
     private writeState: WriteState<TState>;
+    private initialState?: StoreSnapshot<TState>;
 
     public name: string;
     public registrations: StoreRegistrations;
@@ -79,6 +90,9 @@ export default class Store<TState extends BaseState = any> implements InternalSt
         this.scope = effectScope();
         this.writeState = reactive(state) as WriteState<TState>;
         this.readState = readonly(this.writeState) as ReadState<TState>;
+
+        this.once(EVENTS.store.created, () => this.initialState = this.snapshot());
+        this.on(EVENTS.devtools.reset, () => this.reset());
     }
 
     public get allowsOverwrite(): boolean {
@@ -266,6 +280,36 @@ export default class Store<TState extends BaseState = any> implements InternalSt
         return action;
     }
 
+    public snapshot(): StoreSnapshot<TState> {
+        const snapshot = clone(this.state);
+
+        const apply = <TBranchState extends BaseState>(
+            branchAccessor: BranchAccessor<TState, TBranchState> = identity,
+            mutationName: string = MUTATIONS.snapshot) => {
+            this.write(mutationName, SENDER, state => {
+                if (!snapshot) {
+                    return console.warn('Couldn\'t find snapshot for this operation!');
+                }
+
+                const source = branchAccessor(snapshot);
+                const target = branchAccessor(state);
+
+                overwrite(target, clone(source), INTERNAL.pattern);
+            });
+        };
+
+        return {
+            apply,
+            get state() {
+                return clone(snapshot);
+            },
+        };
+    }
+
+    public reset<TBranchState extends BaseState>(branchAccessor: BranchAccessor<TState, TBranchState> = identity) {
+        this.initialState?.apply(branchAccessor, MUTATIONS.reset);
+    }
+
     public write<TResult = void>(name: string, sender: string, mutator: Mutator<TState, undefined, TResult>, suppress?: boolean): TResult {
         const mutation = () => this.mutate(name, sender, mutator, undefined);
 
diff --git a/core/src/types.ts b/core/src/types.ts
index 19ead6f7..6c00ce35 100644
--- a/core/src/types.ts
+++ b/core/src/types.ts
@@ -22,6 +22,7 @@ export type Action<TPayload, TResult = void> = undefined extends TPayload ? (pay
 export type EventHandler<TData = any> = (payload?: EventPayload<TData>) => void;
 export type TriggerHandler<TEventData extends TriggerEventData> = (data: TEventData) => void;
 export type Trigger<TEventData extends TriggerEventData> = (name: string | string[], handler: TriggerHandler<TEventData>) => EventListener;
+export type BranchAccessor<TState extends BaseState, TBranchState extends BaseState> = (state: ReadState<TState> | WriteState<TState>) => TBranchState;
 export type InternalStores = Map<string, InternalStore<any>>;
 export type Extension<TState extends BaseState> = (store: InternalStore<TState>) => Record<string, any>;
 export type ExtensionAPIs<TExtensions extends Extension<any>[]> = UnionToIntersection<ReturnType<TExtensions[number]>>;
@@ -63,6 +64,11 @@ export interface StoreRegistration {
     producer: RegistrationValueProducer;
 }
 
+export interface StoreSnapshot<TState> {
+    get state(): TState;
+    apply<TBranchState extends BaseState>(branchCallback?: BranchAccessor<TState, TBranchState>, mutationName?: string): void;
+}
+
 export interface StoreBase<TState extends BaseState> {
     /**
      * Register a getter on this store
@@ -111,6 +117,18 @@ export interface StoreBase<TState extends BaseState> {
      */
     suppress<TResult = void>(callback: () => TResult): TResult;
 
+    /**
+     * Take a snapshot of this store's current state
+     */
+    snapshot(): StoreSnapshot<TState>;
+
+    /**
+     * Reset this store back to it's intial state
+     *
+     * @param branchAccessor - An optional function that returns a sub-branch of state to reset
+     */
+    reset<TBranchState extends BaseState>(branchAccessor?: BranchAccessor<TState, TBranchState>): void;
+
     /**
      * Destroy this store
      */
diff --git a/core/test/index.test.ts b/core/test/index.test.ts
index f7196fbe..84bb45a4 100644
--- a/core/test/index.test.ts
+++ b/core/test/index.test.ts
@@ -2,9 +2,10 @@ import {
     EventEmitter,
 } from '../src/event-emitter';
 
-import {
+import Harlem, {
     createStore,
-} from '../src/index';
+    INTERNAL,
+} from '../src';
 
 import {
     isRef,
@@ -13,6 +14,7 @@ import {
 
 import {
     afterEach,
+    beforeAll,
     describe,
     expect,
     test,
@@ -28,16 +30,20 @@ function getId() {
 }
 
 function getStore() {
+    const internalKey = `${INTERNAL.prefix}-test`;
+
     const {
-        state,
         getter,
         mutation,
         action,
         ...store
     } = createStore('main', {
         id: 0,
-        firstName: 'John',
-        lastName: 'Smith',
+        details: {
+            firstName: 'John',
+            lastName: 'Smith',
+        },
+        [internalKey]: 10,
     }, {
         allowOverwrite: false,
         // extensions: [
@@ -48,32 +54,30 @@ function getStore() {
         // ],
     });
 
-    const fullName = getter('fullname', state => `${state.firstName} ${state.lastName}`);
+    const fullName = getter('fullname', ({ details }) => `${details.firstName} ${details.lastName}`);
 
-    const setId = mutation<undefined, number>('set-id', state => {
-        const id = getId();
+    const setId = mutation('set-id', (state, payload?: number) => {
+        const id = payload || getId();
 
         state.id = id;
         return id;
     });
 
-    const setFirstName = mutation<string>('set-firstname', (state, payload) => {
-        state.firstName = payload;
-    });
-
-    const setLastName = mutation<string>('set-lastname', (state, payload) => {
-        state.lastName = payload;
+    const setDetails = mutation('set-details', (state, payload: Partial<typeof state.details>) => {
+        state.details = {
+            ...state.details,
+            ...payload,
+        };
     });
 
     return {
-        state,
         getter,
         mutation,
         action,
         fullName,
         setId,
-        setFirstName,
-        setLastName,
+        setDetails,
+        internalKey,
         ...store,
     };
 }
@@ -82,6 +86,18 @@ describe('Harlem Core', () => {
 
     let store = getStore();
 
+    beforeAll(() => {
+        const app = {
+            use: (plugin: any, options?: any) => {
+                if (plugin && plugin.install){
+                    plugin.install(app, options);
+                }
+            },
+        };
+
+        app.use(Harlem);
+    });
+
     afterEach(() => {
         store?.destroy();
         store = getStore();
@@ -123,7 +139,7 @@ describe('Harlem Core', () => {
             const duplicates = [
                 () => createStore('main', {}),
                 () => getter('fullname', () => {}),
-                () => mutation('set-firstname', () => {}),
+                () => mutation('set-details', () => {}),
             ];
 
             duplicates.forEach(invokee => {
@@ -151,8 +167,10 @@ describe('Harlem Core', () => {
                 state,
             } = store;
 
-            expect(state).toHaveProperty('firstName');
-            expect(state).toHaveProperty('lastName');
+            expect(state).toHaveProperty('id');
+            expect(state).toHaveProperty('details');
+            expect(state.details).toHaveProperty('firstName');
+            expect(state.details).toHaveProperty('lastName');
         });
 
         test('Should be readonly', () => {
@@ -163,9 +181,9 @@ describe('Harlem Core', () => {
             vi.spyOn(console, 'warn').getMockImplementation();
 
             // @ts-expect-error This is readonly
-            state.firstName = 'Billy';
+            state.details.firstName = 'Billy';
 
-            expect(state.firstName).toBe('John');
+            expect(state.details.firstName).toBe('John');
             expect(console.warn).toHaveBeenCalledWith(
                 expect.stringContaining('target is readonly'),
                 expect.anything()
@@ -191,15 +209,16 @@ describe('Harlem Core', () => {
         test('Should correctly mutate state', () => {
             const {
                 state,
-                setFirstName,
-                setLastName,
+                setDetails,
             } = store;
 
-            setFirstName('Jane');
-            setLastName('Doe');
+            setDetails({
+                firstName: 'Jane',
+                lastName: 'Doe',
+            });
 
-            expect(state.firstName).toBe('Jane');
-            expect(state.lastName).toBe('Doe');
+            expect(state.details.firstName).toBe('Jane');
+            expect(state.details.lastName).toBe('Doe');
         });
 
         test('Should return a result from a mutation', () => {
@@ -244,16 +263,18 @@ describe('Harlem Core', () => {
 
                 mutate(state => {
                     state.id = id;
-                    state.firstName = 'Jane';
-                    state.lastName = 'Doe';
+                    state.details = {
+                        firstName: 'Jane',
+                        lastName: 'Doe',
+                    };
                 });
             });
 
             await loadDetails(51);
 
             expect(state.id).toBe(51);
-            expect(state.firstName).toBe('Jane');
-            expect(state.lastName).toBe('Doe');
+            expect(state.details.firstName).toBe('Jane');
+            expect(state.details.lastName).toBe('Doe');
         });
 
         test('Should return a result from an action', async () => {
@@ -271,8 +292,10 @@ describe('Harlem Core', () => {
 
                 mutate(state => {
                     state.id = id;
-                    state.firstName = 'Jane';
-                    state.lastName = 'Doe';
+                    state.details = {
+                        firstName: 'Jane',
+                        lastName: 'Doe',
+                    };
                 });
 
                 return id;
@@ -281,8 +304,8 @@ describe('Harlem Core', () => {
             const id = await loadDetails();
 
             expect(id).toBeTypeOf('number');
-            expect(state.firstName).toBe('Jane');
-            expect(state.lastName).toBe('Doe');
+            expect(state.details.firstName).toBe('Jane');
+            expect(state.details.lastName).toBe('Doe');
         });
 
     });
@@ -370,13 +393,164 @@ describe('Harlem Core', () => {
             };
 
             const setRefToState = mutation<typeof payload>('set-ref-to-state', (state, { firstName }) => {
-                state.firstName = firstName as unknown as string;
+                state.details.firstName = firstName as unknown as string;
             });
 
             setRefToState(payload);
 
-            expect(isRef(state.firstName)).toBe(false);
-            expect(state.firstName).toBe('Jim');
+            expect(isRef(state.details.firstName)).toBe(false);
+            expect(state.details.firstName).toBe('Jim');
+        });
+
+    });
+
+    describe('Snapshots', () => {
+
+        test('Should apply a snapshot', () => {
+            const {
+                state,
+                snapshot,
+                setId,
+                setDetails,
+            } = store;
+
+            setId(5);
+            setDetails({
+                firstName: 'Jane',
+                lastName: 'Doe',
+            });
+
+            const snap = snapshot();
+
+            setId(7);
+            setDetails({
+                firstName: 'James',
+                lastName: 'Halpert',
+            });
+
+            expect(state.id).toBe(7);
+            expect(state.details.firstName).toBe('James');
+            expect(state.details.lastName).toBe('Halpert');
+
+            snap.apply();
+
+            expect(state.id).toBe(5);
+            expect(state.details.firstName).toBe('Jane');
+            expect(state.details.lastName).toBe('Doe');
+        });
+
+        test('Should apply a partial snapshot', () => {
+            const {
+                state,
+                setId,
+                setDetails,
+                snapshot,
+            } = store;
+
+            setId(5);
+            setDetails({
+                firstName: 'Jane',
+                lastName: 'Doe',
+            });
+
+            const snap = snapshot();
+
+            setId(7);
+            setDetails({
+                firstName: 'James',
+                lastName: 'Halpert',
+            });
+
+            expect(state.id).toBe(7);
+            expect(state.details.firstName).toBe('James');
+            expect(state.details.lastName).toBe('Halpert');
+
+            snap.apply(state => state.details);
+
+            expect(state.id).toBe(7);
+            expect(state.details.firstName).toBe('Jane');
+            expect(state.details.lastName).toBe('Doe');
+        });
+
+    });
+
+    describe('Resets', () => {
+
+        test('Should perform a basic reset', async () => {
+            const {
+                state,
+                reset,
+                setId,
+                setDetails,
+            } = store;
+
+            setId(5);
+            setDetails({
+                firstName: 'Jane',
+                lastName: 'Doe',
+            });
+
+            expect(state.id).toBe(5);
+            expect(state.details.firstName).toBe('Jane');
+            expect(state.details.lastName).toBe('Doe');
+
+            reset();
+
+            expect(state.id).toBe(0);
+            expect(state.details.firstName).toBe('John');
+            expect(state.details.lastName).toBe('Smith');
+        });
+
+        test('Should perform a partial reset', () => {
+            const {
+                reset,
+                state,
+                setId,
+                setDetails,
+            } = store;
+
+            setId(7);
+            setDetails({
+                firstName: 'Jane',
+                lastName: 'Doe',
+            });
+
+            expect(state.id).toBe(7);
+            expect(state.details.firstName).toBe('Jane');
+            expect(state.details.lastName).toBe('Doe');
+
+            reset(state => state.details);
+
+            expect(state.id).toBe(7);
+            expect(state.details.firstName).toBe('John');
+            expect(state.details.lastName).toBe('Smith');
+        });
+
+        test('Should ignore internal properties', () => {
+            const {
+                reset,
+                state,
+                setId,
+                setDetails,
+                internalKey,
+            } = store;
+
+            setId(7);
+            setDetails({
+                firstName: 'Jane',
+                lastName: 'Doe',
+            });
+
+            expect(state.id).toBe(7);
+            expect(state.details.firstName).toBe('Jane');
+            expect(state.details.lastName).toBe('Doe');
+
+            reset();
+
+            expect(state[internalKey]).toBe(10);
+            expect(state.id).toBe(0);
+            expect(state.details.firstName).toBe('John');
+            expect(state.details.lastName).toBe('Smith');
         });
 
     });