diff --git a/frontend/www/grader/ephemeral/templates/index-light.html b/frontend/www/grader/ephemeral/templates/index-light.html
index bab6610b73..af33780348 100644
--- a/frontend/www/grader/ephemeral/templates/index-light.html
+++ b/frontend/www/grader/ephemeral/templates/index-light.html
@@ -8,8 +8,6 @@
 
 		<title>omegaUp problemless grader &alpha;</title>
 
-		<script src="https://cdnjs.cloudflare.com/ajax/libs/jquery/3.2.1/jquery.min.js"></script>
-		<script src="https://cdnjs.cloudflare.com/ajax/libs/golden-layout/1.5.9/goldenlayout.min.js"></script>
 
 		<link type="text/css" rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/golden-layout/1.5.9/css/goldenlayout-base.css" />
 		<link type="text/css" rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/golden-layout/1.5.9/css/goldenlayout-light-theme.css" />
diff --git a/frontend/www/grader/ephemeral/templates/index.html b/frontend/www/grader/ephemeral/templates/index.html
index 0574342b47..249b894e88 100644
--- a/frontend/www/grader/ephemeral/templates/index.html
+++ b/frontend/www/grader/ephemeral/templates/index.html
@@ -8,9 +8,6 @@
 
 		<title>omegaUp problemless grader &alpha;</title>
 
-		<script src="https://cdnjs.cloudflare.com/ajax/libs/jquery/3.2.1/jquery.min.js"></script>
-		<script src="https://cdnjs.cloudflare.com/ajax/libs/golden-layout/1.5.9/goldenlayout.min.js"></script>
-
 		<link type="text/css" rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/golden-layout/1.5.9/css/goldenlayout-base.css" />
 		<link type="text/css" rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/golden-layout/1.5.9/css/goldenlayout-dark-theme.css" />
 		<link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/4.0.0/css/bootstrap.min.css" integrity="sha384-Gn5384xqQ1aoWXA+058RXPxPg6fy4IWvTNh0E263XmFcJlSAwiGgFAW/dAiS6JXm" crossorigin="anonymous">
diff --git a/frontend/www/js/omegaup/graderv2/CaseSelector.vue b/frontend/www/js/omegaup/graderv2/CaseSelector.vue
index ad409c1e05..ab5d094b1a 100644
--- a/frontend/www/js/omegaup/graderv2/CaseSelector.vue
+++ b/frontend/www/js/omegaup/graderv2/CaseSelector.vue
@@ -96,12 +96,12 @@
 <script lang="ts">
 // TODO: replace all instances of any with correct type
 import { Vue, Component, Prop } from 'vue-property-decorator';
+import store from './GraderStore';
 import * as Util from './util';
 import T from '../lang';
 
 @Component
 export default class CaseSelector extends Vue {
-  @Prop({ required: true }) store!: any;
   @Prop({ required: true }) storeMapping!: any;
   @Prop({ default: 'vs-dark' }) theme!: string;
 
@@ -111,19 +111,17 @@ export default class CaseSelector extends Vue {
 
   get summary(): string {
     if (
-      this.store.state.dirty ||
-      !this.store.state.results ||
-      !this.store.state.results.verdict
+      store.state.dirty ||
+      !store.state.results ||
+      !store.state.results.verdict
     ) {
       return '…';
     }
-    return `${this.store.state.results.verdict} ${this.score(
-      this.store.state.results,
-    )}`;
+    return `${store.state.results.verdict} ${this.score(store.state.results)}`;
   }
 
   get groups(): { [key: string]: any }[] {
-    const flatCases: any = Util.vuexGet(this.store, this.storeMapping.cases);
+    const flatCases: any = Util.vuexGet(store, this.storeMapping.cases);
     const resultMap: { [key: string]: any } = {};
 
     for (const caseName in flatCases) {
@@ -156,17 +154,17 @@ export default class CaseSelector extends Vue {
   }
 
   get currentCase(): string {
-    return Util.vuexGet(this.store, this.storeMapping.currentCase);
+    return Util.vuexGet(store, this.storeMapping.currentCase);
   }
 
   set currentCase(value) {
-    Util.vuexSet(this.store, this.storeMapping.currentCase, value);
+    Util.vuexSet(store, this.storeMapping.currentCase, value);
   }
 
   caseResult(caseName: string): null | any {
-    const flatCaseResults = this.store.getters.flatCaseResults;
+    const flatCaseResults = store.getters.flatCaseResults;
     if (
-      this.store.state.dirty ||
+      store.state.dirty ||
       !Object.prototype.hasOwnProperty.call(flatCaseResults, caseName)
     )
       return null;
@@ -174,8 +172,8 @@ export default class CaseSelector extends Vue {
   }
 
   groupResult(groupName: string): null | any {
-    const results = this.store.state.results;
-    if (this.store.state.dirty || !results || !results.groups) return null;
+    const results = store.state.results;
+    if (store.state.dirty || !results || !results.groups) return null;
     for (const group of results.groups) {
       if (group.group == groupName) return group;
     }
@@ -235,7 +233,7 @@ export default class CaseSelector extends Vue {
 
   createCase(): void {
     if (!this.newCaseName) return;
-    this.store.commit('createCase', {
+    store.commit('createCase', {
       name: this.newCaseName,
       weight: parseFloat(this.newCaseWeight.toString()),
     });
@@ -245,7 +243,7 @@ export default class CaseSelector extends Vue {
   }
 
   removeCase(name: string): void {
-    this.store.commit('removeCase', name);
+    store.commit('removeCase', name);
   }
 }
 </script>
diff --git a/frontend/www/js/omegaup/graderv2/DiffEditor.vue b/frontend/www/js/omegaup/graderv2/DiffEditor.vue
index 2b8f70fbba..0fe5410b68 100644
--- a/frontend/www/js/omegaup/graderv2/DiffEditor.vue
+++ b/frontend/www/js/omegaup/graderv2/DiffEditor.vue
@@ -5,12 +5,12 @@
 <script lang="ts">
 // TODO: replace all instances of any with correct type
 import { Vue, Component, Prop, Watch } from 'vue-property-decorator';
+import store from './GraderStore';
 import * as Util from './util';
 import * as monaco from 'monaco-editor';
 
 @Component
 export default class DiffEditor extends Vue {
-  @Prop({ required: true }) store!: any;
   @Prop({ required: true }) storeMapping!: any;
   @Prop({ default: 'vs-dark' }) theme!: string;
   @Prop({ default: false }) readOnly!: boolean;
@@ -20,11 +20,11 @@ export default class DiffEditor extends Vue {
   _editor: monaco.editor.IStandaloneDiffEditor | null = null;
 
   get originalContents(): string {
-    return Util.vuexGet(this.store, this.storeMapping.originalContents);
+    return Util.vuexGet(store, this.storeMapping.originalContents);
   }
 
   get modifiedContents(): string {
-    return Util.vuexGet(this.store, this.storeMapping.modifiedContents);
+    return Util.vuexGet(store, this.storeMapping.modifiedContents);
   }
 
   @Watch('originalContents')
diff --git a/frontend/www/js/omegaup/graderv2/GraderStore.ts b/frontend/www/js/omegaup/graderv2/GraderStore.ts
index acc355c2de..69ca4ef9c4 100644
--- a/frontend/www/js/omegaup/graderv2/GraderStore.ts
+++ b/frontend/www/js/omegaup/graderv2/GraderStore.ts
@@ -248,6 +248,12 @@ const storeOptions: StoreOptions<GraderStore> = {
     'request.input.interactive.main_source'(state: GraderStore) {
       return state.request.input.interactive?.main_source || '';
     },
+    'request.input.interactive.language'(state: GraderStore) {
+      return state.request.input.interactive?.language || '';
+    },
+    Tolenrance(state: GraderStore) {
+      return state.request.input.validator?.tolerance || -1;
+    },
     isCustomValidator(state: GraderStore) {
       return !!state.request.input.validator.custom_validator;
     },
@@ -530,7 +536,9 @@ const storeOptions: StoreOptions<GraderStore> = {
 
       // update with interactive problem templates for each language
       // dont forget to update all cppxx and pyx templates
-      for (const extension in templates) {
+      for (const lang in templates) {
+        const extension = Util.supportedLanguages[lang].extension;
+
         if (Object.prototype.hasOwnProperty.call(templates, extension)) {
           for (const language of Util.extensionToLanguages[extension]) {
             interactiveTemplates[language] = templates[extension];
@@ -574,7 +582,7 @@ const storeOptions: StoreOptions<GraderStore> = {
       });
       // if we call this function, we must set current case
       // or it could cause errors
-      state.currentCase = caseData.name;
+      store.commit('currentCase', caseData.name);
       state.dirty = true;
     },
     removeCase(state: GraderStore, name: string) {
@@ -645,3 +653,5 @@ const storeOptions: StoreOptions<GraderStore> = {
   strict: true,
 };
 const store = new Vuex.Store<GraderStore>(storeOptions);
+store.commit('reset');
+export default store;
diff --git a/frontend/www/js/omegaup/graderv2/IDESettings.vue b/frontend/www/js/omegaup/graderv2/IDESettings.vue
index 24f0310a15..6b640f460d 100644
--- a/frontend/www/js/omegaup/graderv2/IDESettings.vue
+++ b/frontend/www/js/omegaup/graderv2/IDESettings.vue
@@ -120,6 +120,8 @@
 <script lang="ts">
 import { Vue, Component, Prop } from 'vue-property-decorator';
 import RadioSwitch from '../components/RadioSwitch.vue';
+import store from './GraderStore';
+import * as Util from './util';
 import T from '../lang';
 
 @Component({
@@ -128,100 +130,98 @@ import T from '../lang';
   },
 })
 export default class IDESettings extends Vue {
-  @Prop({ required: true }) store!: any;
   @Prop({ required: true }) storeMapping!: any;
 
   T = T;
-  get timeLimit() {
-    return this.store.state.request.input.limits.TimeLimit;
+  get timeLimit(): number {
+    return Util.parseDuration(store.state.request.input.limits.TimeLimit);
   }
 
   set timeLimit(value: number) {
-    this.store.commit('TimeLimit', Number.parseFloat(value.toString()));
+    store.commit('TimeLimit', value.toString());
   }
 
-  get overallWallTimeLimit() {
-    return this.store.state.request.input.limits.OverallWallTimeLimit;
+  get overallWallTimeLimit(): number {
+    return Util.parseDuration(
+      store.state.request.input.limits.OverallWallTimeLimit,
+    );
   }
 
   set overallWallTimeLimit(value: number) {
-    this.store.commit(
-      'OverallWallTimeLimit',
-      Number.parseFloat(value.toString()),
-    );
+    store.commit('OverallWallTimeLimit', value.toString());
   }
 
-  get extraWallTime() {
-    return this.store.state.request.input.limits.ExtraWallTime;
+  get extraWallTime(): number {
+    return Util.parseDuration(store.state.request.input.limits.ExtraWallTime);
   }
 
   set extraWallTime(value: number) {
-    this.store.commit('ExtraWallTime', Number.parseFloat(value.toString()));
+    store.commit('ExtraWallTime', value.toString());
   }
 
-  get memoryLimit() {
-    return this.store.state.request.input.limits.MemoryLimit;
+  get memoryLimit(): number {
+    return Util.parseDuration(store.state.request.input.limits.MemoryLimit);
   }
 
   set memoryLimit(value: number) {
-    this.store.commit('MemoryLimit', Number.parseInt(value.toString()));
+    store.commit('MemoryLimit', Number.parseInt(value.toString()));
   }
 
-  get outputLimit() {
-    return this.store.state.request.input.limits.OutputLimit;
+  get outputLimit(): number {
+    return Util.parseDuration(store.state.request.input.limits.OutputLimit);
   }
 
   set outputLimit(value: number) {
-    this.store.commit('OutputLimit', Number.parseInt(value.toString()));
+    store.commit('OutputLimit', Number.parseInt(value.toString()));
   }
 
-  get validator() {
-    return this.store.state.request.input.validator.name;
+  get validator(): string {
+    return store.state.request.input.validator.name;
   }
 
   set validator(value: string) {
-    this.store.commit('Validator', value);
+    store.commit('Validator', value);
   }
 
-  get tolerance() {
-    return this.store.state.request.input.validator.tolerance;
+  get tolerance(): number {
+    return store.getters.Tolerance;
   }
 
   set tolerance(value: number) {
-    this.store.commit('Tolerance', value);
+    store.commit('Tolerance', value);
   }
 
-  get validatorLanguage() {
-    return this.store.state.request.input.validator.custom_validator?.language;
+  get validatorLanguage(): string {
+    return store.getters['request.input.validator.custom_validator.language'];
   }
 
   set validatorLanguage(value: string) {
-    this.store.commit('ValidatorLanguage', value);
+    store.commit('ValidatorLanguage', value);
   }
 
-  get interactive() {
-    return this.store.getters.isInteractive;
+  get interactive(): boolean {
+    return store.getters.isInteractive;
   }
 
   set interactive(value: boolean) {
-    if (value) this.store.commit('Interactive', {});
-    else this.store.commit('Interactive', undefined);
+    if (value) store.commit('Interactive', {});
+    else store.commit('Interactive', undefined);
   }
 
-  get interactiveLanguage() {
-    return this.store.state.request.input.interactive.language;
+  get interactiveLanguage(): string {
+    return store.getters['request.input.interactive.language'];
   }
 
   set interactiveLanguage(value: string) {
-    this.store.commit('InteractiveLanguage', value);
+    store.commit('InteractiveLanguage', value);
   }
 
-  get interactiveModuleName() {
-    return this.store.state.request.input.interactive.module_name;
+  get interactiveModuleName(): string {
+    return store.getters.moduleName;
   }
 
   set interactiveModuleName(value: string) {
-    this.store.commit('InteractiveModuleName', value);
+    store.commit('InteractiveModuleName', value);
   }
 }
 </script>
diff --git a/frontend/www/js/omegaup/graderv2/MonacoEditor.vue b/frontend/www/js/omegaup/graderv2/MonacoEditor.vue
index 4c0252d323..226d9ffb93 100644
--- a/frontend/www/js/omegaup/graderv2/MonacoEditor.vue
+++ b/frontend/www/js/omegaup/graderv2/MonacoEditor.vue
@@ -5,12 +5,12 @@
 <script lang="ts">
 // TODO: replace all instances of any with correct type
 import { Vue, Component, Prop, Watch } from 'vue-property-decorator';
+import store from './GraderStore';
 import * as Util from './util';
 import * as monaco from 'monaco-editor';
 
 @Component
 export default class MonacoEditor extends Vue {
-  @Prop({ required: true }) store!: any;
   @Prop({ required: true }) storeMapping!: any;
   @Prop({ default: 'vs-dark' }) theme!: string;
   @Prop({ default: null }) initialModule!: string | null;
@@ -23,20 +23,20 @@ export default class MonacoEditor extends Vue {
 
   get language(): string {
     if (this.initialLanguage) return this.initialLanguage;
-    return Util.vuexGet(this.store, this.storeMapping.language);
+    return Util.vuexGet(store, this.storeMapping.language);
   }
 
   get module(): string {
     if (this.initialModule) return this.initialModule;
-    return Util.vuexGet(this.store, this.storeMapping.module);
+    return Util.vuexGet(store, this.storeMapping.module);
   }
 
   get contents(): string {
-    return Util.vuexGet(this.store, this.storeMapping.contents);
+    return Util.vuexGet(store, this.storeMapping.contents);
   }
 
   set contents(value: string) {
-    Util.vuexSet(this.store, this.storeMapping.contents, value);
+    Util.vuexSet(store, this.storeMapping.contents, value);
   }
 
   get filename(): string {
diff --git a/frontend/www/js/omegaup/graderv2/TextEditor.vue b/frontend/www/js/omegaup/graderv2/TextEditor.vue
index 7612f66cda..1c3a0eca6a 100644
--- a/frontend/www/js/omegaup/graderv2/TextEditor.vue
+++ b/frontend/www/js/omegaup/graderv2/TextEditor.vue
@@ -12,11 +12,11 @@
 <script lang="ts">
 // TODO: replace all instances of any with correct type
 import { Vue, Prop, Component } from 'vue-property-decorator';
+import store from './GraderStore';
 import * as Util from './util';
 
 @Component
 export default class TextEditor extends Vue {
-  @Prop({ required: true }) store!: any;
   @Prop({ required: true }) storeMapping!: any;
   @Prop({ required: true }) extension!: string;
   @Prop({ default: null }) module!: string | null;
@@ -25,7 +25,7 @@ export default class TextEditor extends Vue {
 
   get filename(): string {
     if (typeof this.storeMapping.module !== 'undefined') {
-      return `${Util.vuexGet(this.store, this.storeMapping.module)}.${
+      return `${Util.vuexGet(store, this.storeMapping.module)}.${
         this.extension
       }`;
     }
@@ -33,12 +33,12 @@ export default class TextEditor extends Vue {
   }
 
   get contents(): string {
-    return Util.vuexGet(this.store, this.storeMapping.contents);
+    return Util.vuexGet(store, this.storeMapping.contents);
   }
 
   set contents(value: string) {
     if (this.readOnly) return;
-    Util.vuexSet(this.store, this.storeMapping.contents, value);
+    Util.vuexSet(store, this.storeMapping.contents, value);
   }
 
   get title(): string {
diff --git a/frontend/www/js/omegaup/graderv2/ephemeral.ts b/frontend/www/js/omegaup/graderv2/ephemeral.ts
new file mode 100644
index 0000000000..d612028c7a
--- /dev/null
+++ b/frontend/www/js/omegaup/graderv2/ephemeral.ts
@@ -0,0 +1,937 @@
+/* eslint-disable */
+// @ts-nocheck
+'use strict';
+
+import JSZip from 'jszip';
+import Vue from 'vue';
+import pako from 'pako';
+import GoldenLayout from 'golden-layout';
+
+import * as Util from './util';
+import CaseSelector from './CaseSelector.vue';
+import DiffEditor from './DiffEditor.vue';
+import IDESettings from './IDESettings.vue';
+import MonacoEditor from './MonacoEditor.vue';
+import TextEditor from './TextEditor.vue';
+import ZipViewer from './ZipViewer.vue';
+
+// imports from new files
+import store from './GraderStore';
+
+const isEmbedded = window.location.search.indexOf('embedded') !== -1;
+const theme = document.getElementById('theme').value;
+let isInitialised = false;
+
+const languageExtensionMapping = Object.fromEntries(
+  Object.entries(Util.supportedLanguages).map(([key, value]) => [
+    key,
+    value.extension,
+  ]),
+);
+const goldenLayoutSettings = {
+  settings: {
+    showPopoutIcon: false,
+  },
+  content: [
+    {
+      type: 'row',
+      content: [
+        {
+          type: 'column',
+          id: 'main-column',
+          content: [
+            {
+              type: 'stack',
+              id: 'source-and-settings',
+              content: [
+                {
+                  type: 'component',
+                  componentName: 'monaco-editor-component',
+                  componentState: {
+                    storeMapping: {
+                      contents: 'request.source',
+                      language: 'request.language',
+                      module: 'moduleName',
+                    },
+                    theme,
+                  },
+                  id: 'source',
+                  isClosable: false,
+                },
+                {
+                  type: 'component',
+                  componentName: 'settings-component',
+                  id: 'settings',
+                  componentState: {
+                    storeMapping: {},
+                    id: 'settings',
+                  },
+                  isClosable: false,
+                },
+              ],
+            },
+            {
+              type: 'stack',
+              content: [
+                {
+                  type: 'component',
+                  componentName: 'text-editor-component',
+                  componentState: {
+                    storeMapping: {
+                      contents: 'compilerOutput',
+                    },
+                    id: 'compiler',
+                    readOnly: true,
+                    module: 'compiler',
+                    extension: 'out/err',
+                    theme,
+                  },
+                  isClosable: false,
+                },
+                {
+                  type: 'component',
+                  componentName: 'text-editor-component',
+                  componentState: {
+                    storeMapping: {
+                      contents: 'logs',
+                    },
+                    id: 'logs',
+                    readOnly: true,
+                    module: 'logs',
+                    extension: 'txt',
+                    theme,
+                  },
+                  isClosable: false,
+                },
+                {
+                  type: 'component',
+                  componentName: 'zip-viewer-component',
+                  componentState: {
+                    storeMapping: {},
+                    id: 'zipviewer',
+                    theme,
+                  },
+                  title: 'files.zip',
+                  isClosable: false,
+                },
+              ],
+              height: 20,
+            },
+          ],
+          isClosable: false,
+        },
+        {
+          type: 'column',
+          id: 'cases-column',
+          content: [
+            {
+              type: 'row',
+              content: [
+                {
+                  type: 'component',
+                  componentName: 'text-editor-component',
+                  componentState: {
+                    storeMapping: {
+                      contents: 'inputIn',
+                      module: 'currentCase',
+                    },
+                    id: 'in',
+                    readOnly: false,
+                    extension: 'in',
+                    theme,
+                  },
+                  isClosable: false,
+                },
+                {
+                  type: 'component',
+                  componentName: 'text-editor-component',
+                  componentState: {
+                    storeMapping: {
+                      contents: 'inputOut',
+                      module: 'currentCase',
+                    },
+                    id: 'out',
+                    readOnly: false,
+                    extension: 'out',
+                    theme,
+                  },
+                  isClosable: false,
+                },
+              ],
+            },
+            {
+              type: 'stack',
+              content: [
+                {
+                  type: 'component',
+                  componentName: 'text-editor-component',
+                  componentState: {
+                    storeMapping: {
+                      contents: 'outputStdout',
+                      module: 'currentCase',
+                    },
+                    id: 'stdout',
+                    readOnly: false,
+                    extension: 'out',
+                    theme,
+                  },
+                  isClosable: false,
+                },
+                {
+                  type: 'component',
+                  componentName: 'text-editor-component',
+                  componentState: {
+                    storeMapping: {
+                      contents: 'outputStderr',
+                      module: 'currentCase',
+                    },
+                    id: 'stderr',
+                    readOnly: false,
+                    extension: 'err',
+                    theme,
+                  },
+                  isClosable: false,
+                },
+                {
+                  type: 'component',
+                  componentName: 'monaco-diff-component',
+                  componentState: {
+                    storeMapping: {
+                      originalContents: 'inputOut',
+                      modifiedContents: 'outputStdout',
+                    },
+                    id: 'diff',
+                    theme,
+                  },
+                  isClosable: false,
+                },
+              ],
+            },
+          ],
+          isClosable: false,
+        },
+        {
+          type: 'component',
+          id: 'case-selector-column',
+          componentName: 'case-selector-component',
+          componentState: {
+            storeMapping: {
+              cases: 'request.input.cases',
+              currentCase: 'currentCase',
+            },
+            id: 'source',
+            theme,
+          },
+          title: 'cases/',
+          width: 15,
+          isClosable: false,
+        },
+      ],
+    },
+  ],
+};
+
+// eslint-disable-next-line no-undef
+const layout = new GoldenLayout(
+  goldenLayoutSettings,
+  document.getElementById('layout-root'),
+);
+
+function RegisterVueComponent(layout, componentName, component, componentMap) {
+  layout.registerComponent(componentName, function (container, componentState) {
+    container.on('open', () => {
+      let vueComponents = {};
+      vueComponents[componentName] = component;
+      let props = {
+        storeMapping: componentState.storeMapping,
+      };
+      for (let k in componentState) {
+        if (k == 'id') continue;
+        if (!Object.prototype.hasOwnProperty.call(componentState, k)) continue;
+        props[k] = componentState[k];
+      }
+      let vue = new Vue({
+        el: container.getElement()[0],
+        render: function (createElement) {
+          return createElement(componentName, {
+            props: props,
+          });
+        },
+        components: vueComponents,
+      });
+      let vueComponent = vue.$children[0];
+      if (vueComponent.title) {
+        container.setTitle(vueComponent.title);
+        vueComponent.$watch('title', function (title) {
+          container.setTitle(title);
+        });
+      }
+      if (vueComponent.onResize) {
+        container.on('resize', () => vueComponent.onResize());
+      }
+      componentMap[componentState.id] = vueComponent;
+    });
+  });
+}
+
+let componentMapping = {};
+RegisterVueComponent(
+  layout,
+  'case-selector-component',
+  CaseSelector,
+  componentMapping,
+);
+RegisterVueComponent(
+  layout,
+  'monaco-editor-component',
+  MonacoEditor,
+  componentMapping,
+);
+RegisterVueComponent(
+  layout,
+  'monaco-diff-component',
+  DiffEditor,
+  componentMapping,
+);
+RegisterVueComponent(
+  layout,
+  'settings-component',
+  IDESettings,
+  componentMapping,
+);
+RegisterVueComponent(
+  layout,
+  'text-editor-component',
+  TextEditor,
+  componentMapping,
+);
+RegisterVueComponent(
+  layout,
+  'zip-viewer-component',
+  ZipViewer,
+  componentMapping,
+);
+
+function initialize() {
+  layout.init();
+
+  if (isEmbedded) {
+    // Embedded layout should not be able to modify the settings.
+    layout.root.getItemsById('settings')[0].remove();
+    document.getElementById('download').style.display = 'none';
+    document.getElementById('upload').style.display = 'none';
+    document.querySelector('label[for="upload"]').style.display = 'none';
+
+    // Since the embedded grader has a lot less horizontal space available, we
+    // move the first two columns into a stack so they can be switched between.
+    let mainColumn = layout.root.getItemsById('main-column')[0];
+    let casesColumn = layout.root.getItemsById('cases-column')[0];
+    let caseSelectorColumn = layout.root.getItemsById(
+      'case-selector-column',
+    )[0];
+    let oldWidth = caseSelectorColumn.element[0].clientWidth;
+    let oldHeight = caseSelectorColumn.element[0].clientHeight;
+
+    let newStack = layout.createContentItem({
+      type: 'stack',
+      content: [],
+      isClosable: false,
+    });
+
+    mainColumn.parent.addChild(newStack, 0);
+
+    casesColumn.setTitle('cases');
+    casesColumn.parent.removeChild(casesColumn, true);
+    newStack.addChild(casesColumn, 0);
+
+    mainColumn.setTitle('code');
+    mainColumn.parent.removeChild(mainColumn, true);
+    newStack.addChild(mainColumn, 0);
+
+    // Also extend the case selector column a little bit so that it looks nicer.
+    caseSelectorColumn.container.setSize(Math.max(160, oldWidth), oldHeight);
+
+    // Whenever a case is selected, show the cases tab.
+    store.watch(
+      Object.getOwnPropertyDescriptor(store.getters, 'currentCase').get,
+      (value) => {
+        if (store.getters.isUpdatingSettings) return;
+        casesColumn.parent.setActiveContentItem(casesColumn);
+      },
+    );
+  }
+}
+
+function onResized() {
+  const layoutRoot = document.getElementById('layout-root');
+  if (!layoutRoot.clientWidth) return;
+  if (!isInitialised) {
+    initialize();
+    isInitialised = true;
+  }
+  layout.updateSize();
+}
+
+if (window.ResizeObserver) {
+  new ResizeObserver(onResized).observe(document.getElementById('layout-root'));
+} else {
+  window.addEventListener('resize', onResized);
+}
+onResized();
+
+document.getElementById('language').addEventListener('change', function () {
+  store.commit('request.language', this.value);
+});
+
+function onDetailsJsonReady(results) {
+  store.commit('results', results);
+  store.commit('compilerOutput', results.compile_error || '');
+}
+
+function onFilesZipReady(blob) {
+  if (blob == null || blob.size == 0) {
+    if (componentMapping.zipviewer) {
+      componentMapping.zipviewer.zip = null;
+    }
+    store.commit('clearOutputs');
+    return;
+  }
+  let reader = new FileReader();
+  reader.addEventListener('loadend', (e) => {
+    if (e.target.readyState != FileReader.DONE) return;
+    JSZip.loadAsync(reader.result)
+      .then((zip) => {
+        if (componentMapping.zipviewer) {
+          componentMapping.zipviewer.zip = zip;
+        }
+        store.commit('clearOutputs');
+        Promise.all([
+          zip.file('Main/compile.err').async('string'),
+          zip.file('Main/compile.out').async('string'),
+        ])
+          .then((values) => {
+            for (let value of values) {
+              if (!value) continue;
+              store.commit('compilerOutput', value);
+              return;
+            }
+            store.commit('compilerOutput', '');
+          })
+          .catch(Util.asyncError);
+        for (let filename in zip.files) {
+          if (filename.indexOf('/') !== -1) continue;
+          zip
+            .file(filename)
+            .async('string')
+            .then((contents) => {
+              store.commit('output', {
+                name: filename,
+                contents: contents,
+              });
+            })
+            .catch(Util.asyncError);
+        }
+      })
+      .catch(Util.asyncError);
+  });
+  reader.readAsArrayBuffer(blob);
+}
+
+store.watch(
+  Object.getOwnPropertyDescriptor(store.getters, 'isDirty').get,
+  function (value) {
+    let downloadLabelElement = document.getElementById('download-label');
+    if (!value || !downloadLabelElement) return;
+
+    if (downloadLabelElement.className.indexOf('fa-download') == -1) return;
+    downloadLabelElement.className = downloadLabelElement.className.replace(
+      'fa-download',
+      'fa-file-archive-o',
+    );
+    let downloadElement = document.getElementById('download');
+    downloadElement.download = undefined;
+    downloadElement.href = undefined;
+  },
+);
+
+document.getElementById('upload').addEventListener('change', (e) => {
+  let files = e.target.files;
+  if (!files.length) return;
+
+  let reader = new FileReader();
+  reader.addEventListener('loadend', (e) => {
+    if (e.target.readyState != FileReader.DONE) return;
+    JSZip.loadAsync(reader.result)
+      .then((zip) => {
+        store.commit('reset');
+        store.commit('removeCase', 'long');
+        let cases = {};
+        for (let fileName in zip.files) {
+          if (!Object.prototype.hasOwnProperty.call(zip.files, fileName))
+            continue;
+
+          if (fileName.startsWith('cases/') && fileName.endsWith('.in')) {
+            let caseName = fileName.substring(
+              'cases/'.length,
+              fileName.length - '.in'.length,
+            );
+            cases[caseName] = true;
+            let caseOutFileName = `cases/${caseName}.out`;
+            if (
+              !Object.prototype.hasOwnProperty.call(zip.files, caseOutFileName)
+            )
+              continue;
+            store.commit('createCase', {
+              name: caseName,
+              weight: 1,
+            });
+
+            zip
+              .file(fileName)
+              .async('string')
+              .then((value) => {
+                store.commit('currentCase', caseName);
+                store.commit('inputIn', value);
+              })
+              .catch(Util.asyncError);
+            zip
+              .file(caseOutFileName)
+              .async('string')
+              .then((value) => {
+                store.commit('currentCase', caseName);
+                store.commit('inputOut', value);
+              })
+              .catch(Util.asyncError);
+          } else if (fileName.startsWith('validator.')) {
+            let extension = fileName.substring('validator.'.length);
+            if (
+              !Object.prototype.hasOwnProperty.call(
+                languageExtensionMapping,
+                extension,
+              )
+            )
+              continue;
+            zip
+              .file(fileName)
+              .async('string')
+              .then((value) => {
+                store.commit('Validator', 'custom');
+                store.commit('ValidatorLanguage', extension);
+                store.commit(
+                  'request.input.validator.custom_validator.source',
+                  value,
+                );
+              })
+              .catch(Util.asyncError);
+          } else if (
+            fileName.startsWith('interactive/') &&
+            fileName.endsWith('.idl')
+          ) {
+            let moduleName = fileName.substring(
+              'interactive/'.length,
+              fileName.length - '.idl'.length,
+            );
+            zip
+              .file(fileName)
+              .async('string')
+              .then((value) => {
+                store.commit('Interactive', {
+                  idl: value,
+                  module_name: moduleName,
+                });
+              })
+              .catch(Util.asyncError);
+          } else if (fileName.startsWith('interactive/Main.')) {
+            let extension = fileName.substring('interactive/Main.'.length);
+            if (
+              !Object.prototype.hasOwnProperty.call(
+                languageExtensionMapping,
+                extension,
+              )
+            )
+              continue;
+            zip
+              .file(fileName)
+              .async('string')
+              .then((value) => {
+                store.commit('Interactive', {
+                  language: extension,
+                  main_source: value,
+                });
+              })
+              .catch(Util.asyncError);
+          }
+        }
+
+        if (Object.prototype.hasOwnProperty.call(zip.files, 'testplan')) {
+          zip
+            .file('testplan')
+            .async('string')
+            .then((value) => {
+              for (let line of value.split('\n')) {
+                if (line.startsWith('#') || line.trim() == '') continue;
+                let tokens = line.split(/\s+/);
+                if (tokens.length != 2) continue;
+                let [caseName, weight] = tokens;
+                if (!Object.prototype.hasOwnProperty.call(cases, caseName))
+                  continue;
+                store.commit('createCase', {
+                  name: caseName,
+                  weight: parseFloat(weight),
+                });
+              }
+            })
+            .catch(Util.asyncError);
+        }
+        if (Object.prototype.hasOwnProperty.call(zip.files, 'settings.json')) {
+          zip
+            .file('settings.json')
+            .async('string')
+            .then((value) => {
+              value = JSON.parse(value);
+              if (Object.prototype.hasOwnProperty.call(value, 'Limits')) {
+                for (let name of [
+                  'TimeLimit',
+                  'OverallWallTimeLimit',
+                  'ExtraWallTime',
+                  'MemoryLimit',
+                  'OutputLimit',
+                ]) {
+                  if (!Object.prototype.hasOwnProperty.call(value.Limits, name))
+                    continue;
+                  store.commit(name, value.Limits[name]);
+                }
+              }
+              if (Object.prototype.hasOwnProperty.call(value, 'Validator')) {
+                if (
+                  Object.prototype.hasOwnProperty.call(value.Validator, 'Name')
+                ) {
+                  store.commit('Validator', value.Validator.Name);
+                }
+                if (
+                  Object.prototype.hasOwnProperty.call(
+                    value.Validator,
+                    'Tolerance',
+                  )
+                ) {
+                  store.commit('Tolerance', value.Validator.Tolerance);
+                }
+              }
+            })
+            .catch(Util.asyncError);
+        }
+      })
+      .catch(Util.asyncError);
+  });
+  reader.readAsArrayBuffer(files[0]);
+});
+
+document.getElementById('download').addEventListener('click', (e) => {
+  let downloadLabelElement = document.getElementById('download-label');
+  if (downloadLabelElement.className.indexOf('fa-download') != -1) return true;
+  e.preventDefault();
+
+  let zip = new JSZip();
+  let cases = zip.folder('cases');
+
+  let testplan = '';
+  for (let caseName in store.state.request.input.cases) {
+    if (
+      !Object.prototype.hasOwnProperty.call(
+        store.state.request.input.cases,
+        caseName,
+      )
+    )
+      continue;
+
+    cases.file(`${caseName}.in`, store.state.request.input.cases[caseName].in);
+    cases.file(
+      `${caseName}.out`,
+      store.state.request.input.cases[caseName].out,
+    );
+    testplan +=
+      caseName + ' ' + store.state.request.input.cases[caseName].weight + '\n';
+  }
+  zip.file('testplan', testplan);
+  let settingsValidator = {
+    Name: store.state.request.input.validator.name,
+  };
+  if (
+    Object.prototype.hasOwnProperty.call(
+      store.state.request.input.validator,
+      'tolerance',
+    )
+  ) {
+    settingsValidator.Tolerance = store.state.request.input.validator.Tolerance;
+  }
+  if (
+    Object.prototype.hasOwnProperty.call(
+      store.state.request.input.validator,
+      'custom_validator',
+    )
+  ) {
+    settingsValidator.Lang =
+      store.state.request.input.validator.custom_validator.lang;
+  }
+  zip.file(
+    'settings.json',
+    JSON.stringify(
+      {
+        Cases: store.getters.settingsCases,
+        Limits: store.state.request.input.limits,
+        Validator: settingsValidator,
+      },
+      null,
+      '  ',
+    ),
+  );
+
+  let interactive = store.state.request.input.interactive;
+  if (interactive) {
+    let interactiveFolder = zip.folder('interactive');
+    interactiveFolder.file(`${interactive.module_name}.idl`, interactive.idl);
+    interactiveFolder.file(
+      `Main.${interactive.language}`,
+      interactive.main_source,
+    );
+    interactiveFolder.file(
+      'examples/sample.in',
+      store.state.request.input.cases.sample.in,
+    );
+  }
+
+  let customValidator = store.state.request.input.validator.custom_validator;
+  if (customValidator) {
+    zip.file('validator.' + customValidator.language, customValidator.source);
+  }
+
+  zip
+    .generateAsync({ type: 'blob' })
+    .then((blob) => {
+      downloadLabelElement.className = downloadLabelElement.className.replace(
+        'fa-file-archive-o',
+        'fa-download',
+      );
+      let downloadElement = document.getElementById('download');
+      downloadElement.download = 'omegaup.zip';
+      downloadElement.href = window.URL.createObjectURL(blob);
+    })
+    .catch(Util.asyncError);
+});
+
+const submitButton = document.querySelector('button[data-submit-button]');
+document
+  .querySelector('form.ephemeral-form')
+  .addEventListener('submit', (e) => {
+    e.preventDefault();
+    submitButton.setAttribute('disabled', '');
+    parent.postMessage({
+      method: 'submitRun',
+      params: {
+        problem_alias: store.state.alias,
+        language: store.state.request.language,
+        source: store.state.request.source,
+      },
+    });
+    submitButton.removeAttribute('disabled');
+  });
+
+const runButton = document.querySelector('button[data-run-button]');
+runButton.addEventListener('click', () => {
+  runButton.setAttribute('disabled', '');
+  fetch('run/new/', {
+    method: 'POST',
+    headers: new Headers({
+      'Content-Type': 'application/json',
+    }),
+    body: JSON.stringify(store.state.request),
+  })
+    .then((response) => {
+      if (!response.ok) return null;
+      history.replaceState(
+        undefined,
+        undefined,
+        '#' + response.headers.get('X-OmegaUp-EphemeralToken'),
+      );
+      return response.formData();
+    })
+    .then((formData) => {
+      runButton.removeAttribute('disabled');
+      if (!formData) {
+        onDetailsJsonReady({
+          verdict: 'JE',
+          contest_score: 0,
+          max_score: this.state.max_score,
+        });
+        store.commit('logs', '');
+        onFilesZipReady(null);
+        return;
+      }
+
+      if (formData.has('details.json')) {
+        let reader = new FileReader();
+        reader.addEventListener('loadend', function () {
+          onDetailsJsonReady(JSON.parse(reader.result));
+        });
+        reader.readAsText(formData.get('details.json'));
+      }
+
+      if (formData.has('logs.txt.gz')) {
+        let reader = new FileReader();
+        reader.addEventListener('loadend', function () {
+          if (reader.result.byteLength == 0) {
+            store.commit('logs', '');
+            return;
+          }
+
+          store.commit(
+            'logs',
+            new TextDecoder('utf-8').decode(pako.inflate(reader.result)),
+          );
+        });
+        reader.readAsArrayBuffer(formData.get('logs.txt.gz'));
+      } else {
+        store.commit('logs', '');
+      }
+
+      onFilesZipReady(formData.get('files.zip'));
+    })
+    .catch(Util.asyncError);
+});
+
+function setSettings({ alias, settings, languages, showSubmitButton }) {
+  // if there is not an alias for some reason
+  // should also return early
+  if (!settings || !alias) {
+    return;
+  }
+  store.commit('updatingSettings', true);
+
+  store.commit('Interactive', settings.interactive);
+  store.commit('alias', alias);
+  store.commit('languages', languages);
+  store.commit('showSubmitButton', showSubmitButton);
+  store.commit('limits', settings.limits);
+  store.commit('Validator', settings.validator.name);
+  store.commit('Tolerance', settings.validator.tolerance);
+
+  // create cases for current problem
+  for (let caseName in settings.cases) {
+    if (!Object.prototype.hasOwnProperty.call(settings.cases, caseName))
+      continue;
+    let caseData = settings.cases[caseName];
+    store.commit('createCase', {
+      name: caseName,
+      weight: caseData.weight,
+      in: caseData['in'],
+      out: caseData['out'],
+    });
+  }
+
+  // delete cases that are not in settings cases
+  for (let caseName of Object.keys(store.state.request.input.cases)) {
+    if (Object.prototype.hasOwnProperty.call(settings.cases, caseName))
+      continue;
+    store.commit('removeCase', caseName);
+  }
+  // Given that the current case will change several times, schedule the
+  // flag to avoid swapping into the cases view for the next tick.
+  //
+  // Also change to the main column in case it was not previously selected.
+  setTimeout(() => {
+    store.commit('updatingSettings', false);
+    if (!isInitialised) return;
+    let mainColumn = layout.root.getItemsById('main-column')[0];
+    mainColumn.parent.setActiveContentItem(mainColumn);
+  });
+}
+
+// Add a message listener in case we are embedded or the embedded runner was
+// popped into a full-blown tab.
+window.addEventListener(
+  'message',
+  (e) => {
+    if (e.origin != window.location.origin || !e.data) return;
+
+    switch (e.data.method) {
+      case 'setSettings':
+        setSettings({
+          alias: e.data.params.alias,
+          settings: e.data.params.settings,
+          showSubmitButton: e.data.params.showSubmitButton,
+          languages: e.data.params.languages,
+        });
+        break;
+    }
+  },
+  false,
+);
+
+function onHashChanged() {
+  if (window.location.hash.length == 0) {
+    store.commit('reset');
+    store.commit('logs', '');
+    onDetailsJsonReady({});
+    onFilesZipReady(null);
+    return;
+  }
+  let token = window.location.hash.substring(1);
+  fetch(`run/${token}/request.json`)
+    .then((response) => {
+      if (!response.ok) return null;
+      return response.json();
+    })
+    .then((request) => {
+      if (!request) {
+        store.commit('reset');
+        store.commit('logs', '');
+        onDetailsJsonReady({});
+        onFilesZipReady(null);
+        return;
+      }
+      request.input.limits.ExtraWallTime = Util.parseDuration(
+        request.input.limits.ExtraWallTime,
+      );
+      request.input.limits.OverallWallTimeLimit = Util.parseDuration(
+        request.input.limits.OverallWallTimeLimit,
+      );
+      request.input.limits.TimeLimit = Util.parseDuration(
+        request.input.limits.TimeLimit,
+      );
+      if (!request.input.cases.sample) {
+        // When the run was made programatically, it does not always contain
+        // a sample case. In order to display those runs without crashing,
+        // just create a fake entry with no weight.
+        request.input.cases.sample = {
+          in: '',
+          out: '',
+          weight: 0,
+        };
+      }
+      store.commit('request', request);
+      fetch(`run/${token}/details.json`)
+        .then((response) => {
+          if (!response.ok) return {};
+          return response.json();
+        })
+        .then(onDetailsJsonReady)
+        .catch(Util.asyncError);
+      fetch(`run/${token}/files.zip`)
+        .then((response) => {
+          if (!response.ok) return null;
+          return response.blob();
+        })
+        .then(onFilesZipReady)
+        .catch(Util.asyncError);
+      fetch(`run/${token}/logs.txt`)
+        .then((response) => {
+          if (!response.ok) return '';
+          return response.text();
+        })
+        .then((text) => store.commit('logs', text))
+        .catch(Util.asyncError);
+    })
+    .catch(Util.asyncError);
+}
+window.addEventListener('hashchange', onHashChanged, false);
+onHashChanged();
diff --git a/package.json b/package.json
index 78c45a29d4..84c2585987 100644
--- a/package.json
+++ b/package.json
@@ -74,6 +74,7 @@
     "eslint_d": "^10.0.4",
     "file-loader": "^6.2",
     "fork-ts-checker-webpack-plugin": "^6.1",
+    "golden-layout": "1.5.9",
     "highcharts": "^9.1.0",
     "highcharts-vue": "^1.3.5",
     "html-webpack-plugin": "^4.5",
diff --git a/webpack.config-graderv2.js b/webpack.config-graderv2.js
new file mode 100644
index 0000000000..6b5edb269c
--- /dev/null
+++ b/webpack.config-graderv2.js
@@ -0,0 +1,112 @@
+const path = require('path');
+
+const MonacoWebpackPlugin = require('monaco-editor-webpack-plugin');
+const VueLoaderPlugin = require('vue-loader/lib/plugin');
+const HtmlWebpackPlugin = require('html-webpack-plugin');
+const { CleanWebpackPlugin } = require('clean-webpack-plugin');
+
+module.exports = {
+  name: 'grader',
+  entry: {
+    grader_ephemeral: [
+      '@babel/polyfill',
+      './frontend/www/js/omegaup/graderv2/ephemeral.ts',
+    ],
+  },
+  module: {
+    rules: [
+      {
+        test: /\.vue$/,
+        loader: 'vue-loader',
+      },
+      {
+        test: /\.js$/,
+        exclude: /node_modules/,
+        use: {
+          loader: 'babel-loader',
+          options: {
+            presets: ['@babel/env'],
+            cacheDirectory: true,
+          },
+        },
+      },
+      {
+        test: /\.css$/,
+        use: ['style-loader', 'css-loader'],
+      },
+      {
+        test: /\.ttf$/,
+        use: ['file-loader'],
+      },
+      {
+        test: /\.ts$/,
+        loader: 'ts-loader',
+        options: {
+          appendTsSuffixTo: [/\.vue$/],
+          transpileOnly: true,
+        },
+      },
+      {
+        test: /\.scss$/,
+        use: ['vue-style-loader', 'css-loader', 'sass-loader'],
+      },
+    ],
+  },
+  optimization: {
+    realContentHash: true,
+  },
+  resolve: {
+    extensions: ['.ts', '.js', '.vue'],
+    alias: {
+      vue$: 'vue/dist/vue.common.js',
+      'vue-async-computed': 'vue-async-computed/dist/vue-async-computed.js',
+    },
+    fallback: {
+      buffer: require.resolve('buffer/'),
+      stream: require.resolve('stream-browserify'),
+    },
+  },
+  plugins: [
+    new VueLoaderPlugin(),
+    new MonacoWebpackPlugin(),
+    new HtmlWebpackPlugin({
+      template: path.resolve(
+        __dirname,
+        'frontend/www/grader/ephemeral/templates',
+        'index-light.html',
+      ),
+      filename: path.resolve(
+        __dirname,
+        'frontend/www/grader/ephemeral',
+        'index-light.html',
+      ),
+      scriptLoading: 'defer',
+    }),
+    new HtmlWebpackPlugin({
+      template: path.resolve(
+        __dirname,
+        'frontend/www/grader/ephemeral/templates',
+        'index.html',
+      ),
+      filename: path.resolve(
+        __dirname,
+        'frontend/www/grader/ephemeral',
+        'index.html',
+      ),
+      scriptLoading: 'defer',
+    }),
+    new CleanWebpackPlugin({
+      verbose: true,
+      dry: false,
+      cleanOnceBeforeBuildPatterns: ['grader_ephemeral-*'],
+      dangerouslyAllowCleanPatternsOutsideProject: true,
+    }),
+  ],
+  output: {
+    path: path.resolve(__dirname, './frontend/www/js/dist/'),
+    publicPath: '/js/dist/',
+    filename: '[name]-[contenthash].js',
+    library: '[name]',
+    libraryTarget: 'umd',
+  },
+};
diff --git a/webpack.config.js b/webpack.config.js
index 688bb99f66..05d85df6de 100644
--- a/webpack.config.js
+++ b/webpack.config.js
@@ -4,9 +4,10 @@ const HtmlWebpackPlugin = require('html-webpack-plugin');
 
 const frontendConfig = require('./webpack.config-frontend.js');
 // The following lines of code are required as the current webpack version we are using is producing an error with the openssl library. They have removed a function that webpack is relying on, which is causing this error. These lines of code override the createHash method of the crypto module to avoid the error.
-const crypto = require("crypto");
+const crypto = require('crypto');
 const crypto_orig_createHash = crypto.createHash;
-crypto.createHash = algorithm => crypto_orig_createHash(algorithm == "md4" ? "sha256" : algorithm);
+crypto.createHash = (algorithm) =>
+  crypto_orig_createHash(algorithm == 'md4' ? 'sha256' : algorithm);
 
 // Generate the JSON dependency objects.
 for (const entryname of Object.keys(frontendConfig.entry)) {
@@ -23,7 +24,7 @@ for (const entryname of Object.keys(frontendConfig.entry)) {
 const config = [
   frontendConfig,
   require('./webpack.config-style.js'),
-  require('./webpack.config-grader.js'),
+  require('./webpack.config-graderv2.js'),
 ];
 
 module.exports = (env, argv) => {
diff --git a/yarn.lock b/yarn.lock
index aa40770832..ff4b5b2a74 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -8404,6 +8404,13 @@ globjoin@^0.1.4:
   resolved "https://registry.yarnpkg.com/globjoin/-/globjoin-0.1.4.tgz#2f4494ac8919e3767c5cbb691e9f463324285d43"
   integrity sha1-L0SUrIkZ43Z8XLtpHp9GMyQoXUM=
 
+golden-layout@1.5.9:
+  version "1.5.9"
+  resolved "https://registry.yarnpkg.com/golden-layout/-/golden-layout-1.5.9.tgz#a39bc1f6a67e6f886b797c016dd924e9426ba77f"
+  integrity sha512-iBXDQCXOTgUEQJo96zPbjDoy5bRIk9XW5l+q+pDgLnIyReqaa1aiQctNud4epsskyLt952BG521dew5Z1liSxA==
+  dependencies:
+    jquery "*"
+
 gonzales-pe@^4.3.0:
   version "4.3.0"
   resolved "https://registry.yarnpkg.com/gonzales-pe/-/gonzales-pe-4.3.0.tgz#fe9dec5f3c557eead09ff868c65826be54d067b3"
@@ -10019,6 +10026,11 @@ jest@^26.6.3:
     import-local "^3.0.2"
     jest-cli "^26.6.3"
 
+jquery@*:
+  version "3.7.1"
+  resolved "https://registry.yarnpkg.com/jquery/-/jquery-3.7.1.tgz#083ef98927c9a6a74d05a6af02806566d16274de"
+  integrity sha512-m4avr8yL8kmFN8psrbFFFmB/If14iN5o9nw/NgnnM+kybDJpRsAynV2BsfpTYrTRysYUdADVD7CkUUizgkpLfg==
+
 jquery@^3.5.1:
   version "3.5.1"
   resolved "https://registry.yarnpkg.com/jquery/-/jquery-3.5.1.tgz#d7b4d08e1bfdb86ad2f1a3d039ea17304717abb5"