diff --git a/docs/extensions/guides/README.md b/docs/extensions/guides/README.md
index 06bbbe9e3c..012794a39e 100644
--- a/docs/extensions/guides/README.md
+++ b/docs/extensions/guides/README.md
@@ -24,6 +24,7 @@ Each guide or code sample includes the following:
 | [KubeObjectListLayout](kube-object-list-layout.md) | |
 | [Working with mobx](working-with-mobx.md) | |
 | [Protocol Handlers](protocol-handlers.md) | |
+| [Sending Data between main and renderer](ipc.md) | |
 
 ## Samples
 
diff --git a/docs/extensions/guides/ipc.md b/docs/extensions/guides/ipc.md
new file mode 100644
index 0000000000..91d811bdf0
--- /dev/null
+++ b/docs/extensions/guides/ipc.md
@@ -0,0 +1,131 @@
+# Inter Process Communication
+
+A Lens Extension can utilize IPC to send information between its `LensRendererExtension` and its `LensMainExtension`.
+This is useful when wanting to communicate directly within your extension.
+For example, if a user logs into a service that your extension is a facade for and `main` needs to know some information so that you can start syncing items to the `Catalog`, this would be a good way to send that information along.
+
+IPC channels are blocked off per extension.
+Meaning that each extension can only communicate with itself.
+
+## Types of IPC
+
+There are two flavours of IPC that are provided:
+
+- Event based
+- Request based
+
+### Event Based IPC
+
+This is the same as an [Event Emitter](https://nodejs.org/api/events.html#events_class_eventemitter) but is not limited to just one Javascript process.
+This is a good option when you need to report that something has happened but you don't need a response.
+
+This is a fully two-way form of communication.
+Both `LensMainExtension` and `LensRendererExtension` can do this sort of IPC.
+
+### Request Based IPC
+
+This is more like a Remote Procedure Call (RPC).
+With this sort of IPC the caller waits for the result from the other side.
+This is accomplished by returning a `Promise<T>` which needs to be `await`-ed.
+
+This is a unidirectional form of communication.
+Only `LensRendererExtension` can initiate this kind of request, and only `LensMainExtension` can and respond this this kind of request.
+
+## Registering IPC Handlers and Listeners
+
+The general terminology is as follows:
+
+- A "handler" is the function that responds to a "Request Based IPC" event.
+- A "listener" is the function that is called when a "Event Based IPC" event is emitted.
+
+To register either a handler or a listener, you should do something like the following:
+
+`main.ts`:
+```typescript
+import { LensMainExtension, Interface, Types, Store } from "@k8slens/extensions";
+import { registerListeners, IpcMain } from "./helpers/main";
+
+export class ExampleExtensionMain extends LensMainExtension {
+  onActivate() {
+    IpcMain.createInstance(this);
+  }
+}
+```
+
+This file shows that you need to create an instance of the store to be able to use IPC.
+Lens will automatically clean up that store and all the handlers on deactivation and uninstall.
+
+---
+
+`helpers/main.ts`:
+```typescript
+import { Store } from "@k8slens/extensions";
+
+export class IpcMain extends Store.MainIpcStore {
+  constructor(extension: LensMainExtension) {
+    super(extension);
+
+    this.listenIpc("initialize", onInitialize);
+  }
+}
+
+function onInitialize(event: Types.IpcMainEvent, id: string) {
+  console.log(`starting to initialize: ${id}`);
+}
+```
+
+In other files, it is not necessary to pass around any instances.
+It should be able to just call `getInstance()` everywhere in your extension as needed.
+
+---
+
+`renderer.ts`:
+```typescript
+import { LensRendererExtension, Interface, Types } from "@k8slens/extensions";
+import { IpcRenderer } from "./helpers/renderer";
+
+export class ExampleExtensionRenderer extends LensRendererExtension {
+  onActivate() {
+    const ipc = IpcRenderer.createInstance(this);
+
+    setTimeout(() => ipc.broadcastIpc("initialize", "an-id"), 5000);
+  }
+}
+```
+
+It is also needed to create an instance to broadcast messages too.
+
+---
+
+`helpers/renderer.ts`:
+```typescript
+import { Store } from "@k8slens/extensions";
+
+export class IpcMain extends Store.RendererIpcStore {}
+```
+
+It is necessary to create child classes of these `abstract class`'s in your extension before you can use them.
+
+---
+
+As this example shows: the channel names *must* be the same.
+It should also be noted that "listeners" and "handlers" are specific to either `LensRendererExtension` and `LensMainExtension`.
+There is no behind the scenes transfer of these functions.
+
+If you want to register a "handler" you would call `Store.MainIpcStore.handleIpc(...)` instead.
+The cleanup of these handlers is handled by Lens itself.
+
+`Store.RendererIpcStore.broadcastIpc(...)` and `Store.MainIpcStore.broadcastIpc(...)` sends an event to all renderer frames and to main.
+Because of this, no matter where you broadcast from, all listeners in `main` and `renderer` will be notified.
+
+### Allowed Values
+
+This IPC mechanism utilizes the [Structured Clone Algorithm](developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API/Structured_clone_algorithm) for serialization.
+This means that more types than what are JSON serializable can be used, but not all the information will be passed through.
+
+## Using IPC
+
+Calling IPC is very simple.
+If you are meaning to do an event based call, merely call `broadcastIpc(<channel>, ...<args>)` from within your extension.
+
+If you are meaning to do a request based call from `renderer`, you should do `const res = await Store.RendererIpcStore.invokeIpc(<channel>, ...<args>));` instead.
diff --git a/mkdocs.yml b/mkdocs.yml
index 0496f3001e..fe42cbccf5 100644
--- a/mkdocs.yml
+++ b/mkdocs.yml
@@ -35,6 +35,7 @@ nav:
       - Stores: extensions/guides/stores.md
       - Working with MobX: extensions/guides/working-with-mobx.md
       - Protocol Handlers: extensions/guides/protocol-handlers.md
+      - IPC: extensions/guides/ipc.md
     - Testing and Publishing:
       - Testing Extensions: extensions/testing-and-publishing/testing.md
       - Publishing Extensions: extensions/testing-and-publishing/publishing.md
diff --git a/src/common/ipc/ipc.ts b/src/common/ipc/ipc.ts
index 74305e0484..66e591e765 100644
--- a/src/common/ipc/ipc.ts
+++ b/src/common/ipc/ipc.ts
@@ -42,35 +42,33 @@ function getSubFrames(): ClusterFrameInfo[] {
   return toJS(Array.from(clusterFrameMap.values()), { recurseEverything: true });
 }
 
-export async function broadcastMessage(channel: string, ...args: any[]) {
+export function broadcastMessage(channel: string, ...args: any[]) {
   const views = (webContents || remote?.webContents)?.getAllWebContents();
 
   if (!views) return;
 
-  if (ipcRenderer) {
-    ipcRenderer.send(channel, ...args);
-  } else if (ipcMain) {
-    ipcMain.emit(channel, ...args);
-  }
+  ipcRenderer?.send(channel, ...args);
+  ipcMain?.emit(channel, ...args);
 
-  for (const view of views) {
-    const type = view.getType();
+  const subFramesP = ipcRenderer
+    ? requestMain(subFramesChannel)
+    : Promise.resolve(getSubFrames());
 
-    logger.silly(`[IPC]: broadcasting "${channel}" to ${type}=${view.id}`, { args });
-    view.send(channel, ...args);
+  subFramesP
+    .then(subFrames => {
+      for (const view of views) {
+        try {
+          logger.silly(`[IPC]: broadcasting "${channel}" to ${view.getType()}=${view.id}`, { args });
+          view.send(channel, ...args);
 
-    try {
-      const subFrames: ClusterFrameInfo[] = ipcRenderer
-        ? await requestMain(subFramesChannel)
-        : getSubFrames();
-
-      for (const frameInfo of subFrames) {
-        view.sendToFrame([frameInfo.processId, frameInfo.frameId], channel, ...args);
+          for (const frameInfo of subFrames) {
+            view.sendToFrame([frameInfo.processId, frameInfo.frameId], channel, ...args);
+          }
+        } catch (error) {
+          logger.error("[IPC]: failed to send IPC message", { error: String(error) });
+        }
       }
-    } catch (error) {
-      logger.error("[IPC]: failed to send IPC message", { error: String(error) });
-    }
-  }
+    });
 }
 
 export function subscribeToBroadcast(channel: string, listener: (...args: any[]) => any) {
diff --git a/src/common/ipc/type-enforced-ipc.ts b/src/common/ipc/type-enforced-ipc.ts
index 1c4c7d301d..035ffcd77e 100644
--- a/src/common/ipc/type-enforced-ipc.ts
+++ b/src/common/ipc/type-enforced-ipc.ts
@@ -19,10 +19,12 @@
  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 
+import { ipcMain } from "electron";
 import { EventEmitter } from "events";
 import logger from "../../main/logger";
+import { Disposer } from "../utils";
 
-export type HandlerEvent<EM extends EventEmitter> = Parameters<Parameters<EM["on"]>[1]>[0];
+export type ListenerEvent<EM extends EventEmitter> = Parameters<Parameters<EM["on"]>[1]>[0];
 export type ListVerifier<T extends any[]> = (args: unknown[]) => args is T;
 export type Rest<T> = T extends [any, ...infer R] ? R : [];
 
@@ -34,22 +36,22 @@ export type Rest<T> = T extends [any, ...infer R] ? R : [];
  * @param verifier The function to be called to verify that the args are the correct type
  */
 export function onceCorrect<
-  EM extends EventEmitter,
-  L extends (event: HandlerEvent<EM>, ...args: any[]) => any
+  IPC extends EventEmitter,
+  Listener extends (event: ListenerEvent<IPC>, ...args: any[]) => any
 >({
   source,
   channel,
   listener,
   verifier,
 }: {
-  source: EM,
-  channel: string | symbol,
-  listener: L,
-  verifier: ListVerifier<Rest<Parameters<L>>>,
+  source: IPC,
+  channel: string,
+  listener: Listener,
+  verifier: ListVerifier<Rest<Parameters<Listener>>>,
 }): void {
-  function handler(event: HandlerEvent<EM>, ...args: unknown[]): void {
+  function wrappedListener(event: ListenerEvent<IPC>, ...args: unknown[]): void {
     if (verifier(args)) {
-      source.removeListener(channel, handler); // remove immediately
+      source.removeListener(channel, wrappedListener); // remove immediately
 
       (async () => (listener(event, ...args)))() // might return a promise, or throw, or reject
         .catch((error: any) => logger.error("[IPC]: channel once handler threw error", { channel, error }));
@@ -58,7 +60,7 @@ export function onceCorrect<
     }
   }
 
-  source.on(channel, handler);
+  source.on(channel, wrappedListener);
 }
 
 /**
@@ -68,25 +70,53 @@ export function onceCorrect<
  * @param verifier The function to be called to verify that the args are the correct type
  */
 export function onCorrect<
-  EM extends EventEmitter,
-  L extends (event: HandlerEvent<EM>, ...args: any[]) => any
+  IPC extends EventEmitter,
+  Listener extends (event: ListenerEvent<IPC>, ...args: any[]) => any
 >({
   source,
   channel,
   listener,
   verifier,
 }: {
-  source: EM,
-  channel: string | symbol,
-  listener: L,
-  verifier: ListVerifier<Rest<Parameters<L>>>,
-}): void {
-  source.on(channel, (event, ...args: unknown[]) => {
+  source: IPC,
+  channel: string,
+  listener: Listener,
+  verifier: ListVerifier<Rest<Parameters<Listener>>>,
+}): Disposer {
+  function wrappedListener(event: ListenerEvent<IPC>, ...args: unknown[]) {
     if (verifier(args)) {
       (async () => (listener(event, ...args)))() // might return a promise, or throw, or reject
         .catch(error => logger.error("[IPC]: channel on handler threw error", { channel, error }));
     } else {
       logger.error("[IPC]: channel was emitted with invalid data", { channel, args });
     }
-  });
+  }
+
+  source.on(channel, wrappedListener);
+
+  return () => source.off(channel, wrappedListener);
+}
+
+export function handleCorrect<
+  Handler extends (event: Electron.IpcMainInvokeEvent, ...args: any[]) => any,
+>({
+  channel,
+  handler,
+  verifier,
+}: {
+  channel: string,
+  handler: Handler,
+  verifier: ListVerifier<Rest<Parameters<Handler>>>,
+}): Disposer {
+  function wrappedHandler(event: Electron.IpcMainInvokeEvent, ...args: unknown[]): ReturnType<Handler> {
+    if (verifier(args)) {
+      return handler(event, ...args);
+    }
+
+    throw new TypeError(`Invalid args for invoke on channel: ${channel}`);
+  }
+
+  ipcMain.handle(channel, wrappedHandler);
+
+  return () => ipcMain.removeHandler(channel);
 }
diff --git a/src/extensions/core-api/index.ts b/src/extensions/core-api/index.ts
index 258fdbb6af..4fdca344d9 100644
--- a/src/extensions/core-api/index.ts
+++ b/src/extensions/core-api/index.ts
@@ -31,6 +31,7 @@ import * as Util from "./utils";
 import * as ClusterFeature from "./cluster-feature";
 import * as Interface from "../interfaces";
 import * as Catalog from "./catalog";
+import * as Types from "./types";
 
 export {
   App,
@@ -39,5 +40,6 @@ export {
   ClusterFeature,
   Interface,
   Store,
+  Types,
   Util,
 };
diff --git a/src/extensions/core-api/stores.ts b/src/extensions/core-api/stores.ts
index 17eac539d6..a9dfe9bf1e 100644
--- a/src/extensions/core-api/stores.ts
+++ b/src/extensions/core-api/stores.ts
@@ -20,3 +20,5 @@
  */
 
 export { ExtensionStore } from "../extension-store";
+export { MainIpcStore } from "../main-ipc-store";
+export { RendererIpcStore } from "../renderer-ipc-store";
diff --git a/src/extensions/core-api/types.ts b/src/extensions/core-api/types.ts
new file mode 100644
index 0000000000..ed78b5c017
--- /dev/null
+++ b/src/extensions/core-api/types.ts
@@ -0,0 +1,24 @@
+/**
+ * Copyright (c) 2021 OpenLens Authors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+export type IpcMainInvokeEvent = Electron.IpcMainInvokeEvent;
+export type IpcRendererEvent = Electron.IpcRendererEvent;
+export type IpcMainEvent = Electron.IpcMainEvent;
diff --git a/src/extensions/ipc-store.ts b/src/extensions/ipc-store.ts
new file mode 100644
index 0000000000..541f7b2914
--- /dev/null
+++ b/src/extensions/ipc-store.ts
@@ -0,0 +1,39 @@
+/**
+ * Copyright (c) 2021 OpenLens Authors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+import { Singleton } from "../common/utils";
+import { LensExtension } from "./lens-extension";
+import { createHash } from "crypto";
+import { broadcastMessage } from "../common/ipc";
+
+export const IpcPrefix = Symbol();
+
+export abstract class IpcStore extends Singleton {
+  readonly [IpcPrefix]: string;
+
+  constructor(protected extension: LensExtension) {
+    super();
+    this[IpcPrefix] = createHash("sha256").update(extension.id).digest("hex");
+  }
+
+  broadcastIpc(channel: string, ...args: any[]): void {
+    broadcastMessage(`extensions@${this[IpcPrefix]}:${channel}`, ...args);
+  }
+}
diff --git a/src/extensions/lens-extension.ts b/src/extensions/lens-extension.ts
index cf9077209c..d9df2c9993 100644
--- a/src/extensions/lens-extension.ts
+++ b/src/extensions/lens-extension.ts
@@ -23,7 +23,8 @@ import type { InstalledExtension } from "./extension-discovery";
 import { action, observable, reaction } from "mobx";
 import { FilesystemProvisionerStore } from "../main/extension-filesystem";
 import logger from "../main/logger";
-import { ProtocolHandlerRegistration } from "./registries/protocol-handler-registry";
+import { ProtocolHandlerRegistration } from "./registries";
+import { disposer } from "../common/utils";
 
 export type LensExtensionId = string; // path to manifest (package.json)
 export type LensExtensionConstructor = new (...args: ConstructorParameters<typeof LensExtension>) => LensExtension;
@@ -37,6 +38,8 @@ export interface LensExtensionManifest {
   lens?: object; // fixme: add more required fields for validation
 }
 
+export const Disposers = Symbol();
+
 export class LensExtension {
   readonly id: LensExtensionId;
   readonly manifest: LensExtensionManifest;
@@ -46,6 +49,7 @@ export class LensExtension {
   protocolHandlers: ProtocolHandlerRegistration[] = [];
 
   @observable private isEnabled = false;
+  [Disposers] = disposer();
 
   constructor({ id, manifest, manifestPath, isBundled }: InstalledExtension) {
     this.id = id;
@@ -62,6 +66,10 @@ export class LensExtension {
     return this.manifest.version;
   }
 
+  get description() {
+    return this.manifest.description;
+  }
+
   /**
    * getExtensionFileFolder returns the path to an already created folder. This
    * folder is for the sole use of this extension.
@@ -73,15 +81,11 @@ export class LensExtension {
     return FilesystemProvisionerStore.getInstance().requestDirectory(this.id);
   }
 
-  get description() {
-    return this.manifest.description;
-  }
-
   @action
   async enable() {
     if (this.isEnabled) return;
     this.isEnabled = true;
-    this.onActivate();
+    this.onActivate?.();
     logger.info(`[EXTENSION]: enabled ${this.name}@${this.version}`);
   }
 
@@ -89,7 +93,8 @@ export class LensExtension {
   async disable() {
     if (!this.isEnabled) return;
     this.isEnabled = false;
-    this.onDeactivate();
+    this.onDeactivate?.();
+    this[Disposers]();
     logger.info(`[EXTENSION]: disabled ${this.name}@${this.version}`);
   }
 
@@ -125,12 +130,12 @@ export class LensExtension {
     };
   }
 
-  protected onActivate() {
-    // mock
+  protected onActivate(): void {
+    return;
   }
 
-  protected onDeactivate() {
-    // mock
+  protected onDeactivate(): void {
+    return;
   }
 }
 
diff --git a/src/extensions/lens-main-extension.ts b/src/extensions/lens-main-extension.ts
index 7ae2f06693..b02456c6d4 100644
--- a/src/extensions/lens-main-extension.ts
+++ b/src/extensions/lens-main-extension.ts
@@ -19,12 +19,12 @@
  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  */
 
-import type { MenuRegistration } from "./registries/menu-registry";
 import { LensExtension } from "./lens-extension";
 import { WindowManager } from "../main/window-manager";
 import { getExtensionPageUrl } from "./registries/page-registry";
 import { CatalogEntity, catalogEntityRegistry } from "../common/catalog";
 import { IObservableArray } from "mobx";
+import { MenuRegistration } from "./registries";
 
 export class LensMainExtension extends LensExtension {
   appMenus: MenuRegistration[] = [];
diff --git a/src/extensions/main-ipc-store.ts b/src/extensions/main-ipc-store.ts
new file mode 100644
index 0000000000..1f9241a8b1
--- /dev/null
+++ b/src/extensions/main-ipc-store.ts
@@ -0,0 +1,45 @@
+/**
+ * Copyright (c) 2021 OpenLens Authors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+import { ipcMain } from "electron";
+import { IpcPrefix, IpcStore } from "./ipc-store";
+import { Disposers } from "./lens-extension";
+import { LensMainExtension } from "./lens-main-extension";
+
+export abstract class MainIpcStore extends IpcStore {
+  constructor(extension: LensMainExtension) {
+    super(extension);
+    extension[Disposers].push(() => MainIpcStore.resetInstance());
+  }
+
+  handleIpc(channel: string, handler: (event: Electron.IpcMainInvokeEvent, ...args: any[]) => any): void {
+    const prefixedChannel = `extensions@${this[IpcPrefix]}:${channel}`;
+
+    ipcMain.handle(prefixedChannel, handler);
+    this.extension[Disposers].push(() => ipcMain.removeHandler(prefixedChannel));
+  }
+
+  listenIpc(channel: string, listener: (event: Electron.IpcMainEvent, ...args: any[]) => any): void {
+    const prefixedChannel = `extensions@${this[IpcPrefix]}:${channel}`;
+
+    ipcMain.addListener(prefixedChannel, listener);
+    this.extension[Disposers].push(() => ipcMain.removeListener(prefixedChannel, listener));
+  }
+}
diff --git a/src/extensions/registries/index.ts b/src/extensions/registries/index.ts
index 13d07b2249..7056206daf 100644
--- a/src/extensions/registries/index.ts
+++ b/src/extensions/registries/index.ts
@@ -32,3 +32,4 @@ export * from "./kube-object-status-registry";
 export * from "./command-registry";
 export * from "./entity-setting-registry";
 export * from "./welcome-menu-registry";
+export * from "./protocol-handler-registry";
diff --git a/src/extensions/renderer-ipc-store.ts b/src/extensions/renderer-ipc-store.ts
new file mode 100644
index 0000000000..930027d0e2
--- /dev/null
+++ b/src/extensions/renderer-ipc-store.ts
@@ -0,0 +1,44 @@
+/**
+ * Copyright (c) 2021 OpenLens Authors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+import { ipcRenderer } from "electron";
+import { IpcPrefix, IpcStore } from "./ipc-store";
+import { Disposers } from "./lens-extension";
+import { LensRendererExtension } from "./lens-renderer-extension";
+
+export abstract class RendererIpcStore extends IpcStore {
+  constructor(extension: LensRendererExtension) {
+    super(extension);
+    extension[Disposers].push(() => RendererIpcStore.resetInstance());
+  }
+
+  listenIpc(channel: string, listener: (event: Electron.IpcRendererEvent, ...args: any[]) => any): void {
+    const prefixedChannel = `extensions@${this[IpcPrefix]}:${channel}`;
+
+    ipcRenderer.addListener(prefixedChannel, listener);
+    this.extension[Disposers].push(() => ipcRenderer.removeListener(prefixedChannel, listener));
+  }
+
+  invokeIpc(channel: string, ...args: any[]): Promise<any> {
+    const prefixedChannel = `extensions@${this[IpcPrefix]}:${channel}`;
+
+    return ipcRenderer.invoke(prefixedChannel, ...args);
+  }
+}