diff --git a/Dockerfile b/Dockerfile
index d2c04299d..b52196de9 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -13,10 +13,7 @@ COPY . .
 # Install dependencies
 RUN yarn install
 
-# Build packages (required for the app to work)
-RUN yarn build
-
-# Build the app bundle in production mode (avoids runtime webpack rebuild)
+# Build the app bundle in production mode (the snapp webpack config resolves workspace packages from src)
 RUN NODE_ENV=production yarn snapp build
 
 # Expose port
diff --git a/apps/sensenet/README.md b/apps/sensenet/README.md
index 34ec0099e..24f73527c 100644
--- a/apps/sensenet/README.md
+++ b/apps/sensenet/README.md
@@ -35,6 +35,10 @@ The repositories you've visited will be also saved in your Personal Settings - y
 You can browse the whole repository with the **Content** menu.
 You can adjust the Content view in the personal setting's _"content"_ section.
 
+### Admin UI Applications
+
+The Admin UI can render repository-defined `AUIApplication` contents as small custom HTML applications inside the content explorer. See the [Admin UI Applications documentation](./docs/auiapplications.md) for the content type, bridge API, and repository read/update examples.
+
 ## 🌈 Command palette
 
 The command palette is useful if you want to search in the repository, navigate to a specific page or execute a specific command on the current content.
diff --git a/apps/sensenet/content-types/AUIApplication.xml b/apps/sensenet/content-types/AUIApplication.xml
new file mode 100644
index 000000000..f5382c4a8
--- /dev/null
+++ b/apps/sensenet/content-types/AUIApplication.xml
@@ -0,0 +1,19 @@
+<ContentType name="AUIApplication" parentType="Folder" handler="SenseNet.ContentRepository.Folder" xmlns="http://schemas.sensenet.com/SenseNet/ContentRepository/ContentTypeDefinition">
+  <DisplayName>Admin UI Application</DisplayName>
+  <Description>Custom Admin UI application that renders its HTML field instead of the folder grid.</Description>
+  <Icon>Content</Icon>
+  <AllowIncrementalNaming>true</AllowIncrementalNaming>
+  <Fields>
+    <Field name="Html" type="LongText">
+      <DisplayName>HTML</DisplayName>
+      <Description>HTML rendered by Admin UI when this content is opened. Referenced CSS and JavaScript files can be placed under this application folder and loaded with relative URLs.</Description>
+      <Configuration>
+        <TextType>LongText</TextType>
+        <ControlHint>sn:HtmlEditor</ControlHint>
+        <VisibleBrowse>Show</VisibleBrowse>
+        <VisibleEdit>Show</VisibleEdit>
+        <VisibleNew>Show</VisibleNew>
+      </Configuration>
+    </Field>
+  </Fields>
+</ContentType>
diff --git a/apps/sensenet/docs/auiapplications.md b/apps/sensenet/docs/auiapplications.md
new file mode 100644
index 000000000..e5afe50aa
--- /dev/null
+++ b/apps/sensenet/docs/auiapplications.md
@@ -0,0 +1,348 @@
+# Admin UI Applications
+
+`AUIApplication` is a lightweight extension point for the sensenet Admin UI. It lets repository editors create a folder-like content that contains custom HTML. When the Admin UI opens this content, it renders the HTML in place of the regular child grid.
+
+This is useful for small internal admin tools, dashboards, data fix-up screens, reports, and workflow helpers that should live in the repository instead of being compiled into the Admin UI bundle.
+
+## Content Type
+
+The content type definition is available here:
+
+```text
+apps/sensenet/content-types/AUIApplication.xml
+```
+
+It derives from `Folder` and adds one editable field:
+
+```xml
+<Field name="Html" type="LongText">
+  <DisplayName>HTML</DisplayName>
+  <Configuration>
+    <TextType>LongText</TextType>
+    <ControlHint>sn:HtmlEditor</ControlHint>
+    <VisibleBrowse>Show</VisibleBrowse>
+    <VisibleEdit>Show</VisibleEdit>
+    <VisibleNew>Show</VisibleNew>
+  </Configuration>
+</Field>
+```
+
+After the CTD exists in the repository, create a new `AUIApplication` content anywhere under `/Root/Content`, then put the application markup into its `Html` field.
+
+## Rendering Model
+
+When the current content has type `AUIApplication`, `Explore` renders `AUIApplicationView` instead of the grid.
+
+The custom HTML is loaded from the `Html` field and rendered in an iframe. The iframe receives:
+
+```js
+window.sensenetAdminApp
+```
+
+This object is injected by the Admin UI before your HTML runs.
+
+## Bridge Concept
+
+The HTML app runs inside an iframe. Calling the repository directly from that iframe can hit CORS or authentication problems, and exposing the bearer token directly to arbitrary HTML would be a bad extension pattern.
+
+Instead, the Admin UI provides a small bridge:
+
+1. Your HTML calls `window.sensenetAdminApp.fetch(...)`.
+2. The iframe sends a `postMessage` request to the parent Admin UI.
+3. The parent Admin UI validates that the request targets the current repository.
+4. The parent calls `repository.fetch(...)`.
+5. The normal Admin UI auth header/token is attached by the repository client.
+6. The response body is sent back to the iframe.
+
+So custom apps can use authenticated repository APIs without reading or storing the token themselves.
+
+## Available API
+
+```ts
+window.sensenetAdminApp = {
+  repositoryUrl: string
+  adminUiUrl: string
+  content: {
+    Id?: number
+    Path?: string
+    Name?: string
+    DisplayName?: string
+    Type?: string
+  }
+  fetch(input: string, init?: {
+    method?: string
+    headers?: Record<string, string>
+    body?: string
+  }): Promise<BridgeResponse>
+}
+```
+
+The `fetch` function intentionally supports a small subset of the browser `fetch` API:
+
+```ts
+type BridgeResponse = {
+  ok: boolean
+  status: number
+  statusText: string
+  url: string
+  headers: {
+    get(name: string): string | null
+    entries(): Array<[string, string]>
+  }
+  text(): Promise<string>
+  json(): Promise<any>
+}
+```
+
+Requests are restricted to the current repository origin. Cross-repository and arbitrary external requests are rejected by the parent Admin UI.
+
+## URL Rules
+
+Use repository-relative URLs when possible:
+
+```js
+await window.sensenetAdminApp.fetch('/odata.svc/Root/Content')
+```
+
+Absolute URLs are also accepted if they point to the same repository origin:
+
+```js
+await window.sensenetAdminApp.fetch('https://example.test.sensenet.com/odata.svc/Root/Content')
+```
+
+Use `adminUiUrl` when you need to navigate back to Admin UI routes. Do not use root-relative links for Admin UI navigation inside an `AUIApplication`, because the injected `<base>` tag points relative asset URLs to the repository content path.
+
+```js
+const adminPath = (path) => path.replace(/^\/Root(?=\/|$)/, '') || '/'
+const adminUiUrl = window.sensenetAdminApp.adminUiUrl || new URL(document.referrer).origin
+const query = new URLSearchParams({
+  path: adminPath('/Root/Content/test/BannerImages'),
+  content: adminPath('/Root/Content/test/BannerImages/example.png'),
+})
+
+const editUrl = `${adminUiUrl}/content/explorer/edit?${query.toString()}`
+```
+
+For assets such as CSS or JavaScript, the Admin UI injects a `<base>` tag that points to the current `AUIApplication` content path. This means relative references can point to files stored under the application folder:
+
+```html
+<link rel="stylesheet" href="styles.css" />
+<script src="app.js"></script>
+```
+
+## Read Children
+
+```js
+const app = window.sensenetAdminApp
+
+async function loadChildren(path) {
+  const url =
+    `/odata.svc${path}` +
+    '?$select=Id,Path,Name,DisplayName,Type,IsFolder,IsFile,CreationDate,ModificationDate' +
+    '&$orderby=Name'
+
+  const response = await app.fetch(url, {
+    headers: {
+      Accept: 'application/json',
+    },
+  })
+
+  if (!response.ok) {
+    throw new Error(`${response.status} ${response.statusText}`)
+  }
+
+  const result = await response.json()
+
+  return result.d.results
+}
+
+const items = await loadChildren('/Root/Content/test/BannerImages')
+console.log(items)
+```
+
+## Read One Content
+
+```js
+async function loadContent(path) {
+  const response = await window.sensenetAdminApp.fetch(
+    `/odata.svc${path}?$select=Id,Path,Name,DisplayName,Type,Description`,
+    {
+      headers: {
+        Accept: 'application/json',
+      },
+    },
+  )
+
+  if (!response.ok) {
+    throw new Error(`${response.status} ${response.statusText}`)
+  }
+
+  const result = await response.json()
+
+  return result.d
+}
+```
+
+## Update Content
+
+Use `PATCH` for partial updates. Always send a JSON string body and set `Content-Type`.
+
+```js
+async function updateDisplayName(path, displayName) {
+  const response = await window.sensenetAdminApp.fetch(`/odata.svc${path}`, {
+    method: 'PATCH',
+    headers: {
+      Accept: 'application/json',
+      'Content-Type': 'application/json',
+    },
+    body: JSON.stringify({
+      DisplayName: displayName,
+    }),
+  })
+
+  if (!response.ok) {
+    const details = await response.text()
+    throw new Error(`Update failed: ${response.status} ${response.statusText} ${details}`)
+  }
+
+  return response.json()
+}
+
+await updateDisplayName('/Root/Content/test/BannerImages/example.png', 'New display name')
+```
+
+## Create Content
+
+Use `POST` on the parent path and include `__ContentType`.
+
+```js
+async function createFolder(parentPath, name, displayName) {
+  const response = await window.sensenetAdminApp.fetch(`/odata.svc${parentPath}`, {
+    method: 'POST',
+    headers: {
+      Accept: 'application/json',
+      'Content-Type': 'application/json',
+    },
+    body: JSON.stringify({
+      __ContentType: 'Folder',
+      Name: name,
+      DisplayName: displayName,
+    }),
+  })
+
+  if (!response.ok) {
+    const details = await response.text()
+    throw new Error(`Create failed: ${response.status} ${response.statusText} ${details}`)
+  }
+
+  return response.json()
+}
+
+await createFolder('/Root/Content/test', 'NewBannerFolder', 'New banner folder')
+```
+
+## Small Helper Wrapper
+
+For real applications, define a tiny repository helper in your HTML or external JavaScript file:
+
+```js
+const sn = {
+  request: async (url, init = {}) => {
+    const response = await window.sensenetAdminApp.fetch(url, {
+      ...init,
+      headers: {
+        Accept: 'application/json',
+        ...(init.body ? { 'Content-Type': 'application/json' } : {}),
+        ...(init.headers || {}),
+      },
+    })
+
+    if (!response.ok) {
+      const details = await response.text()
+      throw new Error(`${response.status} ${response.statusText}: ${details}`)
+    }
+
+    return response.json()
+  },
+
+  loadChildren: async (path) => {
+    const result = await sn.request(`/odata.svc${path}?$select=Id,Path,Name,DisplayName,Type&$orderby=Name`)
+    return result.d.results
+  },
+
+  patch: async (path, content) => {
+    const result = await sn.request(`/odata.svc${path}`, {
+      method: 'PATCH',
+      body: JSON.stringify(content),
+    })
+    return result.d
+  },
+}
+```
+
+## Example Application
+
+The first example application is here:
+
+```text
+apps/sensenet/examples/auiapplication-banner-images.html
+```
+
+It lists the children of:
+
+```text
+/Root/Content/test/BannerImages
+```
+
+The table displays `Name` and `Type`, and each row has an Edit button that navigates back to the normal Admin UI edit view.
+
+## Recommended Structure
+
+For small tools, putting everything into the `Html` field is fine:
+
+```html
+<main>...</main>
+<style>
+  ...;
+</style>
+<script>
+  ...
+</script>
+```
+
+For larger tools, store assets under the `AUIApplication` folder:
+
+```text
+MyAdminTool
+  index HTML in the Html field
+  app.js
+  styles.css
+```
+
+Then reference them with relative URLs:
+
+```html
+<link rel="stylesheet" href="styles.css" />
+<script src="app.js"></script>
+```
+
+## Security Notes
+
+`AUIApplication` is a powerful extension point. Treat it as trusted admin-defined code.
+
+Important guardrails:
+
+- The bridge does not expose the bearer token to the iframe.
+- Bridge requests are restricted to the current repository origin.
+- The iframe is sandboxed and does not get direct parent DOM access.
+- User-clicked links may navigate the top-level Admin UI window, which is needed for Edit links and similar Admin UI routes.
+- Users who can edit an `AUIApplication` can run JavaScript inside the Admin UI page, so editing rights should be limited to trusted administrators.
+- Do not paste third-party scripts into an `AUIApplication` unless they are reviewed and trusted.
+
+## Limitations
+
+- `sensenetAdminApp.fetch` is not a full browser `fetch` replacement.
+- Request bodies must currently be strings. Use `JSON.stringify(...)` for JSON payloads.
+- The response object supports `ok`, `status`, `statusText`, `url`, `headers.get`, `headers.entries`, `text()`, and `json()`.
+- File upload and streaming APIs are not exposed through this bridge yet.
+- High-level repository methods such as `load`, `patch`, or `post` are not exposed directly. Build tiny wrappers around `fetch` in your app.
diff --git a/apps/sensenet/examples/auiapplication-active-users.html b/apps/sensenet/examples/auiapplication-active-users.html
new file mode 100644
index 000000000..f2b6ff2d5
--- /dev/null
+++ b/apps/sensenet/examples/auiapplication-active-users.html
@@ -0,0 +1,329 @@
+<main class="app-shell">
+  <header class="hero">
+    <p class="eyebrow">Admin UI Application példa</p>
+    <h1>Aktív userek</h1>
+    <p class="intro">
+      Ó, admin UI istene, ki a káoszból táblázatot, a bizonytalanságból jogosultságot, a kattintásból pedig
+      működő workflow-t teremtesz: legyen ma kegyes hozzánk a grid, és mutassa meg a
+      <code>/Root/IMS</code> alatt élő aktív felhasználókat.
+    </p>
+  </header>
+
+  <section class="panel">
+    <div class="panel-header">
+      <div>
+        <h2>Felhasználók</h2>
+        <p id="summary" class="summary">Betöltés...</p>
+      </div>
+      <div class="toolbar">
+        <input id="search-input" type="search" placeholder="Keresés név vagy email alapján" />
+        <button id="refresh-button" type="button">Frissítés</button>
+      </div>
+    </div>
+
+    <div id="status" class="status">Betöltés...</div>
+
+    <table id="users-table" hidden>
+      <thead>
+        <tr>
+          <th>FullName</th>
+          <th>Email</th>
+        </tr>
+      </thead>
+      <tbody id="users-table-body"></tbody>
+    </table>
+  </section>
+</main>
+
+<style>
+  :root {
+    color: #e8eef2;
+    background: #101718;
+    font-family: Arial, Helvetica, sans-serif;
+  }
+
+  body {
+    margin: 0;
+    background: #101718;
+  }
+
+  .app-shell {
+    min-height: 100vh;
+    padding: 32px;
+    box-sizing: border-box;
+  }
+
+  .hero {
+    max-width: 1080px;
+    margin: 0 auto 24px;
+  }
+
+  .eyebrow {
+    margin: 0 0 8px;
+    color: #29a8df;
+    font-size: 13px;
+    font-weight: 700;
+    text-transform: uppercase;
+  }
+
+  h1,
+  h2,
+  p {
+    margin-top: 0;
+  }
+
+  h1 {
+    margin-bottom: 10px;
+    font-size: 32px;
+    line-height: 1.2;
+  }
+
+  .intro {
+    max-width: 860px;
+    margin-bottom: 0;
+    color: #aebcc3;
+    line-height: 1.55;
+  }
+
+  code {
+    color: #fff;
+  }
+
+  .panel {
+    max-width: 1080px;
+    margin: 0 auto;
+    border: 1px solid rgba(255, 255, 255, 0.14);
+    background: #151d1f;
+  }
+
+  .panel-header {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    gap: 20px;
+    padding: 16px 18px;
+    border-bottom: 1px solid rgba(255, 255, 255, 0.14);
+  }
+
+  .panel-header h2 {
+    margin: 0 0 4px;
+    font-size: 18px;
+  }
+
+  .summary {
+    margin: 0;
+    color: #aebcc3;
+    font-size: 13px;
+  }
+
+  .toolbar {
+    display: flex;
+    align-items: center;
+    gap: 10px;
+  }
+
+  input {
+    width: 280px;
+    max-width: 38vw;
+    height: 36px;
+    border: 1px solid rgba(255, 255, 255, 0.18);
+    border-radius: 3px;
+    padding: 0 10px;
+    box-sizing: border-box;
+    background: #101718;
+    color: #e8eef2;
+  }
+
+  input:focus {
+    border-color: #29a8df;
+    outline: none;
+  }
+
+  button {
+    height: 36px;
+    border: 0;
+    border-radius: 3px;
+    padding: 0 14px;
+    background: #0192db;
+    color: #fff;
+    font-weight: 700;
+    cursor: pointer;
+  }
+
+  button:hover {
+    background: #16a7ef;
+  }
+
+  .status {
+    padding: 18px;
+    color: #aebcc3;
+  }
+
+  .status.error {
+    color: #ffb6b6;
+  }
+
+  table {
+    width: 100%;
+    border-collapse: collapse;
+  }
+
+  th,
+  td {
+    padding: 11px 18px;
+    border-bottom: 1px solid rgba(255, 255, 255, 0.1);
+    text-align: left;
+    vertical-align: middle;
+  }
+
+  th {
+    color: #aebcc3;
+    font-size: 12px;
+    text-transform: uppercase;
+  }
+
+  tr:hover td {
+    background: rgba(255, 255, 255, 0.04);
+  }
+
+  .muted {
+    color: #8fa0a8;
+  }
+
+  @media (max-width: 760px) {
+    .app-shell {
+      padding: 20px;
+    }
+
+    .panel-header,
+    .toolbar {
+      align-items: stretch;
+      flex-direction: column;
+    }
+
+    input {
+      width: 100%;
+      max-width: none;
+    }
+  }
+</style>
+
+<script>
+  ;(() => {
+    const targetPath = '/Root/IMS'
+    const adminApp = window.sensenetAdminApp || {}
+    const status = document.getElementById('status')
+    const summary = document.getElementById('summary')
+    const table = document.getElementById('users-table')
+    const tableBody = document.getElementById('users-table-body')
+    const refreshButton = document.getElementById('refresh-button')
+    const searchInput = document.getElementById('search-input')
+    let users = []
+
+    const setStatus = (message, isError = false) => {
+      status.textContent = message
+      status.classList.toggle('error', isError)
+      status.hidden = false
+      table.hidden = true
+    }
+
+    const escapeHtml = (value) =>
+      String(value || '').replace(/[&<>"']/g, (character) => {
+        const entities = {
+          '&': '&amp;',
+          '<': '&lt;',
+          '>': '&gt;',
+          '"': '&quot;',
+          "'": '&#039;',
+        }
+
+        return entities[character]
+      })
+
+    const getDisplayValue = (value) => escapeHtml(value || '<nincs kitöltve>')
+
+    const buildUsersUrl = () => {
+      const params = new URLSearchParams({
+        '$select': 'Id,Path,Name,DisplayName,FullName,Email,Enabled',
+        '$orderby': 'FullName,Name',
+        '$top': '10000',
+        metadata: 'no',
+        query: `TypeIs:User AND InTree:"${targetPath}" .AUTOFILTERS:OFF`,
+      })
+
+      return `/odata.svc${targetPath}?${params.toString()}`
+    }
+
+    const renderUsers = () => {
+      const term = searchInput.value.trim().toLowerCase()
+      const visibleUsers = term
+        ? users.filter((user) =>
+            `${user.FullName || ''} ${user.Email || ''}`.toLowerCase().includes(term),
+          )
+        : users
+
+      summary.textContent = `${visibleUsers.length} aktív user megjelenítve`
+
+      if (!visibleUsers.length) {
+        setStatus(users.length ? 'Nincs találat a keresésre.' : 'Nincs aktív user a /Root/IMS alatt.')
+        return
+      }
+
+      tableBody.innerHTML = visibleUsers
+        .map(
+          (user) => `
+            <tr>
+              <td>${getDisplayValue(user.FullName || user.DisplayName || user.Name)}</td>
+              <td>${getDisplayValue(user.Email)}</td>
+            </tr>
+          `,
+        )
+        .join('')
+
+      status.hidden = true
+      table.hidden = false
+    }
+
+    const loadUsers = async () => {
+      if (!adminApp.fetch) {
+        setStatus(
+          'Nem található AUIApplication fetch bridge. Az alkalmazás csak az Admin UI AUIApplication nézetében futtatva működik.',
+          true,
+        )
+        return
+      }
+
+      setStatus('Aktív userek betöltése...')
+      summary.textContent = 'Betöltés...'
+
+      try {
+        const response = await adminApp.fetch(buildUsersUrl(), {
+          headers: {
+            Accept: 'application/json',
+          },
+        })
+
+        if (!response.ok) {
+          const details = await response.text()
+          throw new Error(`${response.status} ${response.statusText} ${details}`)
+        }
+
+        const result = await response.json()
+        const allUsers = result.d && result.d.results ? result.d.results : []
+        users = allUsers.filter((user) => user.Enabled === true)
+
+        renderUsers()
+      } catch (error) {
+        summary.textContent = 'Nem sikerült betölteni a listát.'
+        setStatus(
+          `Nem sikerült betölteni az aktív usereket. Részletek: ${error.message || error}`,
+          true,
+        )
+      }
+    }
+
+    refreshButton.addEventListener('click', loadUsers)
+    searchInput.addEventListener('input', renderUsers)
+    loadUsers()
+  })()
+</script>
diff --git a/apps/sensenet/examples/auiapplication-banner-images.html b/apps/sensenet/examples/auiapplication-banner-images.html
new file mode 100644
index 000000000..d8a1eb055
--- /dev/null
+++ b/apps/sensenet/examples/auiapplication-banner-images.html
@@ -0,0 +1,278 @@
+<main class="app-shell">
+  <header class="hero">
+    <p class="eyebrow">Admin UI Application példa</p>
+    <h1>Banner képek</h1>
+    <p class="intro">
+      Ez a kis alkalmazás a <code>/Root/Content/test/BannerImages</code> alatti contenteket listázza, és minden sorhoz
+      ad egy gyors szerkesztés gombot.
+    </p>
+  </header>
+
+  <section class="panel">
+    <div class="panel-header">
+      <h2>Contentek</h2>
+      <button id="refresh-button" type="button">Frissítés</button>
+    </div>
+
+    <div id="status" class="status">Betöltés...</div>
+
+    <table id="content-table" hidden>
+      <thead>
+        <tr>
+          <th>Name</th>
+          <th>Típus</th>
+          <th></th>
+        </tr>
+      </thead>
+      <tbody id="content-table-body"></tbody>
+    </table>
+  </section>
+</main>
+
+<style>
+  :root {
+    color: #e8eef2;
+    background: #101718;
+    font-family: Arial, Helvetica, sans-serif;
+  }
+
+  body {
+    margin: 0;
+    background: #101718;
+  }
+
+  .app-shell {
+    min-height: 100vh;
+    padding: 32px;
+    box-sizing: border-box;
+  }
+
+  .hero {
+    max-width: 980px;
+    margin: 0 auto 24px;
+  }
+
+  .eyebrow {
+    margin: 0 0 8px;
+    color: #29a8df;
+    font-size: 13px;
+    font-weight: 700;
+    text-transform: uppercase;
+  }
+
+  h1,
+  h2,
+  p {
+    margin-top: 0;
+  }
+
+  h1 {
+    margin-bottom: 8px;
+    font-size: 32px;
+    line-height: 1.2;
+  }
+
+  .intro {
+    max-width: 720px;
+    margin-bottom: 0;
+    color: #aebcc3;
+    line-height: 1.5;
+  }
+
+  code {
+    color: #fff;
+  }
+
+  .panel {
+    max-width: 980px;
+    margin: 0 auto;
+    border: 1px solid rgba(255, 255, 255, 0.14);
+    background: #151d1f;
+  }
+
+  .panel-header {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    gap: 16px;
+    padding: 16px 18px;
+    border-bottom: 1px solid rgba(255, 255, 255, 0.14);
+  }
+
+  .panel-header h2 {
+    margin: 0;
+    font-size: 18px;
+  }
+
+  button,
+  .edit-link {
+    border: 0;
+    border-radius: 3px;
+    padding: 8px 12px;
+    background: #0192db;
+    color: #fff;
+    font-weight: 700;
+    text-decoration: none;
+    cursor: pointer;
+  }
+
+  button:hover,
+  .edit-link:hover {
+    background: #16a7ef;
+  }
+
+  .status {
+    padding: 18px;
+    color: #aebcc3;
+  }
+
+  .status.error {
+    color: #ffb6b6;
+  }
+
+  table {
+    width: 100%;
+    border-collapse: collapse;
+  }
+
+  th,
+  td {
+    padding: 11px 18px;
+    border-bottom: 1px solid rgba(255, 255, 255, 0.1);
+    text-align: left;
+    vertical-align: middle;
+  }
+
+  th {
+    color: #aebcc3;
+    font-size: 12px;
+    text-transform: uppercase;
+  }
+
+  td:last-child,
+  th:last-child {
+    width: 1%;
+    white-space: nowrap;
+    text-align: right;
+  }
+
+  tr:hover td {
+    background: rgba(255, 255, 255, 0.04);
+  }
+</style>
+
+<script>
+  ;(() => {
+    const targetPath = '/Root/Content/test/BannerImages'
+    const adminApp = window.sensenetAdminApp || {}
+    const status = document.getElementById('status')
+    const table = document.getElementById('content-table')
+    const tableBody = document.getElementById('content-table-body')
+    const refreshButton = document.getElementById('refresh-button')
+
+    const setStatus = (message, isError = false) => {
+      status.textContent = message
+      status.classList.toggle('error', isError)
+      status.hidden = false
+      table.hidden = true
+    }
+
+    const escapeHtml = (value) =>
+      String(value || '').replace(/[&<>"']/g, (character) => {
+        const entities = {
+          '&': '&amp;',
+          '<': '&lt;',
+          '>': '&gt;',
+          '"': '&quot;',
+          "'": '&#039;',
+        }
+
+        return entities[character]
+      })
+
+    const toAdminContentPath = (path) => path.replace(/^\/Root(?=\/|$)/, '') || '/'
+
+    const getAdminUiUrl = () => {
+      if (adminApp.adminUiUrl) {
+        return adminApp.adminUiUrl.replace(/\/+$/, '')
+      }
+
+      if (document.referrer) {
+        return new URL(document.referrer).origin
+      }
+
+      return ''
+    }
+
+    const getEditUrl = (contentPath) => {
+      const adminUiUrl = getAdminUiUrl()
+      const query = new URLSearchParams({
+        path: toAdminContentPath(targetPath),
+        content: toAdminContentPath(contentPath),
+      })
+      const editPath = `/content/explorer/edit?${query.toString()}`
+
+      return adminUiUrl ? `${adminUiUrl}${editPath}` : editPath
+    }
+
+    const loadContents = async () => {
+      if (!adminApp.fetch) {
+        setStatus(
+          'Nem található AUIApplication fetch bridge. Az alkalmazás csak az Admin UI AUIApplication nézetében futtatva működik.',
+          true,
+        )
+        return
+      }
+
+      setStatus('Betöltés...')
+
+      try {
+        const url = `/odata.svc${targetPath}?$select=Id,Name,DisplayName,Type,Path&$orderby=Name`
+        const response = await adminApp.fetch(url, {
+          headers: {
+            Accept: 'application/json',
+          },
+        })
+
+        if (!response.ok) {
+          throw new Error(`${response.status} ${response.statusText}`)
+        }
+
+        const result = await response.json()
+        const contents = result.d && result.d.results ? result.d.results : []
+
+        if (!contents.length) {
+          setStatus('Nincs megjeleníthető content ebben a mappában.')
+          return
+        }
+
+        tableBody.innerHTML = contents
+          .map(
+            (content) => `
+              <tr>
+                <td>${escapeHtml(content.Name)}</td>
+                <td>${escapeHtml(content.Type)}</td>
+                <td>
+                  <a class="edit-link" href="${getEditUrl(content.Path)}" target="_top">Edit</a>
+                </td>
+              </tr>
+            `,
+          )
+          .join('')
+
+        status.hidden = true
+        table.hidden = false
+      } catch (error) {
+        setStatus(
+          `Nem sikerült betölteni a contenteket. Részletek: ${
+            error.message || error
+          }. Ellenőrizd, hogy van-e jogosultságod a célmappához.`,
+          true,
+        )
+      }
+    }
+
+    refreshButton.addEventListener('click', loadContents)
+    loadContents()
+  })()
+</script>
diff --git a/apps/sensenet/src/components/BatchActions.tsx b/apps/sensenet/src/components/BatchActions.tsx
index 6e8ab84ff..15b45ae58 100644
--- a/apps/sensenet/src/components/BatchActions.tsx
+++ b/apps/sensenet/src/components/BatchActions.tsx
@@ -1,11 +1,16 @@
-import { createStyles, IconButton, makeStyles, Theme, Tooltip } from '@material-ui/core'
+import { CircularProgress, createStyles, IconButton, makeStyles, Theme, Tooltip } from '@material-ui/core'
+import ArchiveIcon from '@material-ui/icons/Archive'
+import AppsIcon from '@material-ui/icons/Apps'
 import DeleteIcon from '@material-ui/icons/Delete'
 import FileCopyIcon from '@material-ui/icons/FileCopy'
 import FileCopyOutlinedIcon from '@material-ui/icons/FileCopyOutlined'
-import { CurrentContentContext } from '@sensenet/hooks-react'
+import TableChartIcon from '@material-ui/icons/TableChart'
+import { CurrentContentContext, useLogger, useRepository } from '@sensenet/hooks-react'
 import React, { useContext, useEffect, useState } from 'react'
 import { useGlobalStyles } from '../globalStyles'
 import { useLocalization, useSelectionService } from '../hooks'
+import { downloadContentsAsZip } from '../services/zip-download'
+import { CsvExportDialog } from './CsvExportDialog'
 import { useDialog } from './dialogs'
 
 const useStyles = makeStyles((theme: Theme) =>
@@ -36,7 +41,11 @@ export const BatchActions = () => {
   const globalClasses = useGlobalStyles()
   const classes = useStyles()
   const { openDialog } = useDialog()
+  const repository = useRepository()
+  const logger = useLogger('BatchActions')
   const [selected, setSelected] = useState(selectionService.selection.getValue())
+  const [isExportDialogOpen, setIsExportDialogOpen] = useState(false)
+  const [isZipDownloading, setIsZipDownloading] = useState(false)
   const parent = useContext(CurrentContentContext)
 
   useEffect(() => {
@@ -49,8 +58,96 @@ export const BatchActions = () => {
     }
   }, [selectionService.selection])
 
+  const downloadSelectedContentAsZip = async () => {
+    if (!selected.length || isZipDownloading) {
+      return
+    }
+
+    setIsZipDownloading(true)
+
+    try {
+      const result = await downloadContentsAsZip({ repository, contents: selected, parent })
+
+      logger.information({
+        message: localization.batchActions.downloadZipSuccess
+          .replace('{0}', String(result.fileCount))
+          .replace('{1}', String(result.folderCount)),
+        data: {
+          relatedRepository: repository.configuration.repositoryUrl,
+          details: {
+            fileCount: result.fileCount,
+            folderCount: result.folderCount,
+            skippedContentCount: result.skippedContentCount,
+            fileName: result.fileName,
+          },
+        },
+      })
+    } catch (error) {
+      logger.error({
+        message: localization.batchActions.downloadZipError,
+        data: {
+          error,
+          relatedRepository: repository.configuration.repositoryUrl,
+          details: {
+            selectedContentCount: selected.length,
+          },
+        },
+      })
+    } finally {
+      setIsZipDownloading(false)
+    }
+  }
+
   return (
     <div className={classes.batchActionWrapper} data-test="batch-actions">
+      <Tooltip title={localization.customActions.oDataActionsDialog.menuTitle} placement="bottom">
+        <span>
+          <IconButton
+            className={classes.actionButton}
+            data-test="batch-odata-actions"
+            aria-label="odata-actions"
+            disabled={selected.length !== 1}
+            onClick={() =>
+              openDialog({
+                name: 'odata-actions',
+                props: { content: selected[0] },
+                dialogProps: { classes: { paper: globalClasses.pickerDialog } },
+              })
+            }>
+            <AppsIcon />
+          </IconButton>
+        </span>
+      </Tooltip>
+      <Tooltip title={localization.batchActions.exportCsv} placement="bottom">
+        <span>
+          <IconButton
+            className={classes.actionButton}
+            data-test="batch-export-csv"
+            aria-label="export-csv"
+            disabled={selected.length === 0}
+            onClick={() => setIsExportDialogOpen(true)}>
+            <TableChartIcon />
+          </IconButton>
+        </span>
+      </Tooltip>
+      <CsvExportDialog
+        open={isExportDialogOpen}
+        selected={selected}
+        parent={parent}
+        onClose={() => setIsExportDialogOpen(false)}
+      />
+      <Tooltip title={localization.batchActions.downloadZip} placement="bottom">
+        <span>
+          <IconButton
+            className={classes.actionButton}
+            data-test="batch-download-zip"
+            aria-label="download-zip"
+            disabled={selected.length === 0 || isZipDownloading}
+            onClick={downloadSelectedContentAsZip}>
+            {isZipDownloading ? <CircularProgress size={22} color="inherit" /> : <ArchiveIcon />}
+          </IconButton>
+        </span>
+      </Tooltip>
       <Tooltip title={localization.batchActions.delete} placement="bottom">
         <span>
           <IconButton
diff --git a/apps/sensenet/src/components/CsvExportDialog.tsx b/apps/sensenet/src/components/CsvExportDialog.tsx
new file mode 100644
index 000000000..a9616e95a
--- /dev/null
+++ b/apps/sensenet/src/components/CsvExportDialog.tsx
@@ -0,0 +1,448 @@
+import {
+  Button,
+  Checkbox,
+  Chip,
+  createStyles,
+  Dialog,
+  DialogActions,
+  DialogContent,
+  FormControl,
+  FormControlLabel,
+  InputLabel,
+  makeStyles,
+  MenuItem,
+  Select,
+  TextField,
+  Theme,
+  Typography,
+} from '@material-ui/core'
+import { FieldSetting, FieldVisibility, GenericContent } from '@sensenet/default-content-types'
+import { useLogger, useRepository } from '@sensenet/hooks-react'
+import React, { useEffect, useMemo, useState } from 'react'
+import { useLocalization } from '../hooks'
+import { createCsvFromContents, downloadCsv, getCsvExportFileName, preferredCsvColumns } from '../services/csv-export'
+import { DialogTitle } from './dialogs'
+
+type CsvFieldOption = {
+  name: string
+  displayName: string
+  type: string
+  visibleBrowse?: FieldVisibility
+}
+
+type CsvExportDialogProps = {
+  open: boolean
+  selected: GenericContent[]
+  parent?: GenericContent
+  onClose: () => void
+}
+
+const systemFieldOptions = preferredCsvColumns.map<CsvFieldOption>((fieldName) => ({
+  name: fieldName,
+  displayName: fieldName,
+  type: 'System',
+  visibleBrowse: FieldVisibility.Show,
+}))
+const exportRequestBatchSize = 8
+
+const useStyles = makeStyles((theme: Theme) =>
+  createStyles({
+    content: {
+      display: 'flex',
+      flexDirection: 'column',
+      gap: theme.spacing(2),
+      minHeight: '420px',
+    },
+    layout: {
+      display: 'grid',
+      gridTemplateColumns: 'minmax(260px, 360px) 1fr',
+      gap: theme.spacing(3),
+      [theme.breakpoints.down('xs')]: {
+        gridTemplateColumns: '1fr',
+      },
+    },
+    fieldToolbar: {
+      display: 'flex',
+      gap: theme.spacing(1),
+      margin: `${theme.spacing(1)}px 0`,
+    },
+    fieldList: {
+      border: `1px solid ${theme.palette.divider}`,
+      maxHeight: '300px',
+      overflowY: 'auto',
+      padding: theme.spacing(1),
+    },
+    fieldLabel: {
+      alignItems: 'flex-start',
+      display: 'flex',
+      marginRight: 0,
+      width: '100%',
+    },
+    fieldLabelText: {
+      display: 'flex',
+      flexDirection: 'column',
+      minWidth: 0,
+    },
+    fieldName: {
+      overflow: 'hidden',
+      textOverflow: 'ellipsis',
+      whiteSpace: 'nowrap',
+    },
+    fieldMeta: {
+      color: theme.palette.text.secondary,
+      fontSize: '0.75rem',
+      overflow: 'hidden',
+      textOverflow: 'ellipsis',
+      whiteSpace: 'nowrap',
+    },
+    selectedFields: {
+      alignContent: 'flex-start',
+      border: `1px solid ${theme.palette.divider}`,
+      display: 'flex',
+      flexWrap: 'wrap',
+      gap: theme.spacing(1),
+      marginTop: theme.spacing(1),
+      maxHeight: '300px',
+      minHeight: '128px',
+      overflowY: 'auto',
+      padding: theme.spacing(1),
+    },
+    selectedFieldsHeader: {
+      alignItems: 'center',
+      display: 'flex',
+      gap: theme.spacing(1),
+      justifyContent: 'space-between',
+    },
+  }),
+)
+
+const getContentTypeNames = (contents: GenericContent[]) =>
+  Array.from(new Set(contents.map((content) => content.Type).filter(Boolean))).sort((left, right) =>
+    left.localeCompare(right),
+  )
+
+const getSortedFieldOptions = (fieldOptions: CsvFieldOption[]) =>
+  [...fieldOptions].sort((left, right) => {
+    const leftPreferredIndex = preferredCsvColumns.indexOf(left.name)
+    const rightPreferredIndex = preferredCsvColumns.indexOf(right.name)
+
+    if (leftPreferredIndex >= 0 || rightPreferredIndex >= 0) {
+      if (leftPreferredIndex === -1) {
+        return 1
+      }
+      if (rightPreferredIndex === -1) {
+        return -1
+      }
+      return leftPreferredIndex - rightPreferredIndex
+    }
+
+    return left.displayName.localeCompare(right.displayName)
+  })
+
+const getFieldOptionsForContentType = (fieldSettings: FieldSetting[]) => {
+  const fieldOptionsByName = new Map(systemFieldOptions.map((fieldOption) => [fieldOption.name, fieldOption]))
+
+  fieldSettings.forEach((fieldSetting) => {
+    fieldOptionsByName.set(fieldSetting.Name, {
+      name: fieldSetting.Name,
+      displayName: fieldSetting.DisplayName || fieldSetting.Name,
+      type: fieldSetting.Type,
+      visibleBrowse: fieldSetting.VisibleBrowse,
+    })
+  })
+
+  return getSortedFieldOptions(Array.from(fieldOptionsByName.values()))
+}
+
+const getDefaultSelectedFields = (contentTypeFieldOptions: CsvFieldOption[][]) => {
+  const fieldNames = new Set(preferredCsvColumns)
+
+  contentTypeFieldOptions.forEach((fieldOptions) => {
+    fieldOptions.forEach((fieldOption) => {
+      if (fieldOption.visibleBrowse === FieldVisibility.Show) {
+        fieldNames.add(fieldOption.name)
+      }
+    })
+  })
+
+  return Array.from(fieldNames)
+}
+
+const loadContentsForExport = async (
+  contents: GenericContent[],
+  loadContent: (content: GenericContent) => Promise<GenericContent>,
+) => {
+  const loadedContents: GenericContent[] = []
+
+  for (let startIndex = 0; startIndex < contents.length; startIndex += exportRequestBatchSize) {
+    const contentBatch = contents.slice(startIndex, startIndex + exportRequestBatchSize)
+    const loadedBatch = await Promise.all(contentBatch.map(loadContent))
+    loadedContents.push(...loadedBatch)
+  }
+
+  return loadedContents
+}
+
+export const CsvExportDialog: React.FC<CsvExportDialogProps> = ({ open, selected, parent, onClose }) => {
+  const classes = useStyles()
+  const localization = useLocalization()
+  const logger = useLogger('CsvExportDialog')
+  const repository = useRepository()
+  const contentTypeNames = useMemo(() => getContentTypeNames(selected), [selected])
+  const [activeContentType, setActiveContentType] = useState('')
+  const [selectedFields, setSelectedFields] = useState<string[]>([])
+  const [searchTerm, setSearchTerm] = useState('')
+  const [isExporting, setIsExporting] = useState(false)
+
+  const fieldOptionsByContentType = useMemo(() => {
+    return contentTypeNames.reduce((optionsByType, contentTypeName) => {
+      const schema = repository.schemas.getSchemaByName(contentTypeName)
+      optionsByType[contentTypeName] = getFieldOptionsForContentType(schema.FieldSettings)
+
+      return optionsByType
+    }, {} as Record<string, CsvFieldOption[]>)
+  }, [contentTypeNames, repository.schemas])
+
+  useEffect(() => {
+    if (!open) {
+      return
+    }
+
+    setActiveContentType(contentTypeNames[0] || '')
+    setSelectedFields(contentTypeNames.length ? getDefaultSelectedFields(Object.values(fieldOptionsByContentType)) : [])
+    setSearchTerm('')
+  }, [contentTypeNames, fieldOptionsByContentType, open])
+
+  const activeFieldOptions = activeContentType ? fieldOptionsByContentType[activeContentType] || [] : []
+  const filteredFieldOptions = activeFieldOptions.filter((fieldOption) => {
+    const normalizedSearchTerm = searchTerm.toLocaleLowerCase()
+
+    return (
+      fieldOption.name.toLocaleLowerCase().includes(normalizedSearchTerm) ||
+      fieldOption.displayName.toLocaleLowerCase().includes(normalizedSearchTerm) ||
+      fieldOption.type.toLocaleLowerCase().includes(normalizedSearchTerm)
+    )
+  })
+
+  const fieldLabelsByName = useMemo(() => {
+    const labelsByName = new Map<string, string>()
+
+    Object.values(fieldOptionsByContentType).forEach((fieldOptions) => {
+      fieldOptions.forEach((fieldOption) => {
+        if (!labelsByName.has(fieldOption.name)) {
+          labelsByName.set(fieldOption.name, fieldOption.displayName)
+        }
+      })
+    })
+
+    return labelsByName
+  }, [fieldOptionsByContentType])
+
+  const getFieldLabel = (fieldName: string) => {
+    const displayName = fieldLabelsByName.get(fieldName)
+
+    return displayName && displayName !== fieldName ? `${displayName} (${fieldName})` : fieldName
+  }
+
+  const toggleField = (fieldName: string) => {
+    setSelectedFields((currentFields) =>
+      currentFields.includes(fieldName)
+        ? currentFields.filter((currentField) => currentField !== fieldName)
+        : [...currentFields, fieldName],
+    )
+  }
+
+  const selectActiveContentTypeFields = () => {
+    setSelectedFields((currentFields) =>
+      Array.from(new Set([...currentFields, ...activeFieldOptions.map((fieldOption) => fieldOption.name)])),
+    )
+  }
+
+  const clearActiveContentTypeFields = () => {
+    const activeFieldNames = new Set(activeFieldOptions.map((fieldOption) => fieldOption.name))
+    setSelectedFields((currentFields) => currentFields.filter((fieldName) => !activeFieldNames.has(fieldName)))
+  }
+
+  const exportSelectedContent = async () => {
+    if (!selected.length || !selectedFields.length) {
+      return
+    }
+
+    setIsExporting(true)
+
+    try {
+      const contents = await loadContentsForExport(selected, async (content) => {
+        const response = await repository.load<GenericContent>({
+          idOrPath: content.Id,
+          oDataOptions: { select: 'all' },
+        })
+
+        return response.d
+      })
+      const csvContent = createCsvFromContents(contents, selectedFields)
+
+      downloadCsv(csvContent, getCsvExportFileName(contents, parent))
+      logger.information({
+        message: localization.batchActions.exportCsvSuccess.replace('{0}', String(contents.length)),
+        data: {
+          relatedRepository: repository.configuration.repositoryUrl,
+          details: {
+            exportedContentCount: contents.length,
+            selectedFieldCount: selectedFields.length,
+          },
+        },
+      })
+      onClose()
+    } catch (error) {
+      logger.error({
+        message: localization.batchActions.exportCsvError,
+        data: {
+          error,
+          relatedRepository: repository.configuration.repositoryUrl,
+          details: {
+            selectedContentCount: selected.length,
+            selectedFields,
+          },
+        },
+      })
+    } finally {
+      setIsExporting(false)
+    }
+  }
+
+  const selectionSummary = localization.batchActions.exportCsvSelectionSummary
+    .replace('{0}', String(selected.length))
+    .replace('{1}', String(contentTypeNames.length))
+  const selectedFieldSummary = localization.batchActions.exportCsvSelectedFieldCount.replace(
+    '{0}',
+    String(selectedFields.length),
+  )
+
+  return (
+    <Dialog
+      open={open}
+      onClose={isExporting ? undefined : onClose}
+      maxWidth="md"
+      fullWidth
+      data-test="csv-export-dialog">
+      <DialogTitle>{localization.batchActions.exportCsvDialogTitle}</DialogTitle>
+      <DialogContent className={classes.content}>
+        <Typography variant="body2" color="textSecondary">
+          {selectionSummary}
+        </Typography>
+        <div className={classes.layout}>
+          <div>
+            <FormControl variant="outlined" fullWidth>
+              <InputLabel id="csv-export-content-type-label">
+                {localization.batchActions.exportCsvContentType}
+              </InputLabel>
+              <Select
+                labelId="csv-export-content-type-label"
+                value={activeContentType}
+                onChange={(event) => setActiveContentType(event.target.value as string)}
+                label={localization.batchActions.exportCsvContentType}>
+                {contentTypeNames.map((contentTypeName) => (
+                  <MenuItem key={contentTypeName} value={contentTypeName}>
+                    {contentTypeName}
+                  </MenuItem>
+                ))}
+              </Select>
+            </FormControl>
+            <TextField
+              value={searchTerm}
+              onChange={(event) => setSearchTerm(event.target.value)}
+              label={localization.batchActions.exportCsvSearchFields}
+              variant="outlined"
+              margin="normal"
+              fullWidth
+            />
+            <div className={classes.fieldToolbar}>
+              <Button size="small" onClick={selectActiveContentTypeFields} disabled={!activeFieldOptions.length}>
+                {localization.batchActions.exportCsvSelectAllTypeFields}
+              </Button>
+              <Button size="small" onClick={clearActiveContentTypeFields} disabled={!activeFieldOptions.length}>
+                {localization.batchActions.exportCsvClearTypeFields}
+              </Button>
+            </div>
+            <div className={classes.fieldList} data-test="csv-export-field-list">
+              {filteredFieldOptions.length ? (
+                filteredFieldOptions.map((fieldOption) => (
+                  <FormControlLabel
+                    key={fieldOption.name}
+                    className={classes.fieldLabel}
+                    control={
+                      <Checkbox
+                        color="primary"
+                        checked={selectedFields.includes(fieldOption.name)}
+                        onChange={() => toggleField(fieldOption.name)}
+                      />
+                    }
+                    label={
+                      <span className={classes.fieldLabelText}>
+                        <span className={classes.fieldName}>{fieldOption.displayName}</span>
+                        <span className={classes.fieldMeta}>
+                          {fieldOption.name} - {fieldOption.type}
+                        </span>
+                      </span>
+                    }
+                  />
+                ))
+              ) : (
+                <Typography variant="body2" color="textSecondary">
+                  {localization.batchActions.exportCsvNoFields}
+                </Typography>
+              )}
+            </div>
+          </div>
+          <div>
+            <div className={classes.selectedFieldsHeader}>
+              <div>
+                <Typography variant="subtitle2">{localization.batchActions.exportCsvSelectedFields}</Typography>
+                <Typography variant="caption" color="textSecondary">
+                  {selectedFieldSummary}
+                </Typography>
+              </div>
+              <Button
+                size="small"
+                onClick={() => setSelectedFields([])}
+                disabled={!selectedFields.length || isExporting}>
+                {localization.batchActions.exportCsvClearSelectedFields}
+              </Button>
+            </div>
+            <div className={classes.selectedFields} data-test="csv-export-selected-fields">
+              {selectedFields.length ? (
+                selectedFields.map((fieldName) => (
+                  <Chip
+                    key={fieldName}
+                    label={getFieldLabel(fieldName)}
+                    onDelete={() =>
+                      setSelectedFields((currentFields) =>
+                        currentFields.filter((currentField) => currentField !== fieldName),
+                      )
+                    }
+                  />
+                ))
+              ) : (
+                <Typography variant="body2" color="textSecondary">
+                  {localization.batchActions.exportCsvNoSelectedFields}
+                </Typography>
+              )}
+            </div>
+          </div>
+        </div>
+      </DialogContent>
+      <DialogActions>
+        <Button onClick={onClose} disabled={isExporting}>
+          {localization.forms.cancel}
+        </Button>
+        <Button
+          color="primary"
+          variant="contained"
+          onClick={exportSelectedContent}
+          disabled={!selected.length || !selectedFields.length || isExporting}>
+          {isExporting ? localization.batchActions.exportCsvExporting : localization.batchActions.exportCsvExportButton}
+        </Button>
+      </DialogActions>
+    </Dialog>
+  )
+}
diff --git a/apps/sensenet/src/components/Home.tsx b/apps/sensenet/src/components/Home.tsx
index 558076674..69dbefe4b 100644
--- a/apps/sensenet/src/components/Home.tsx
+++ b/apps/sensenet/src/components/Home.tsx
@@ -16,12 +16,16 @@ import Typography from '@material-ui/core/Typography'
 import ExpandMoreIcon from '@material-ui/icons/ExpandMore'
 import { useRepository } from '@sensenet/hooks-react'
 import React, { lazy, useEffect, useState } from 'react'
-// import { useAuth } from '../context/auth-provider'
+import { useAuth } from '../context/auth-provider'
 import { useLocalization } from '../hooks'
 import { DateTimeFormatter } from './grid/Formatters/DateTimeFormatter'
+import { HomeActivitySummary } from './home-activity-summary'
 
 const DashboardComponent = lazy(() => import(/* webpackChunkName: "dashboard" */ './dashboard'))
 
+const latestChangesLimit = 100
+const latestChangesWindowInMinutes = 600
+
 const useStyles = makeStyles((theme: Theme) =>
   createStyles({
     homeCont: {
@@ -178,7 +182,7 @@ export const Home = () => {
   const classes = useStyles()
   const repo = useRepository()
   const localization = useLocalization().home
-  // const { user } = useAuth()
+  const { user } = useAuth()
 
   const [lastMinuteLogs, setLastMinuteLogs] = useState<any[]>([])
   // const [myLogs, setMyLogs] = useState<any[]>([])
@@ -200,10 +204,17 @@ export const Home = () => {
         setHasGetLogs(canGetLogs)
         // setHasGetTopLogsByUser(canGetUserLogs)
 
-        if (canGetLogs) await getLatestChanges()
+        if (canGetLogs) {
+          await getLatestChanges()
+        } else {
+          setLastMinuteLogs([])
+        }
         // if (canGetUserLogs) await getMyChanges()
       } catch (error: any) {
         console.error('Fetching actions failed:', error.message)
+        setCanContentHistory(false)
+        setHasGetLogs(false)
+        setLastMinuteLogs([])
       }
     }
 
@@ -214,8 +225,9 @@ export const Home = () => {
           name: 'LogEntries/GetLogsForLastMinutes',
           method: 'GET',
           oDataOptions: {
-            top: 100,
-            minutes: 600,
+            limit: latestChangesLimit,
+            minutes: latestChangesWindowInMinutes,
+            top: latestChangesLimit,
           } as any,
         })
 
@@ -327,6 +339,11 @@ export const Home = () => {
       <div className={classes.gridsCont}>
         {hasGetLogs && (
           <div className={classes.gridCont}>
+            <HomeActivitySummary
+              logs={lastMinuteLogs}
+              user={user}
+              repositoryUrl={repo.configuration.repositoryUrl}
+            />
             <h2>{localization.latestChanges}</h2>
             {lastMinuteLogs.map((log, index) => {
               const hasChanges = log.ExtendedProperties?.ChangedData?.length > 0
diff --git a/apps/sensenet/src/components/Icon.tsx b/apps/sensenet/src/components/Icon.tsx
index 4bfc42af6..89be9d744 100644
--- a/apps/sensenet/src/components/Icon.tsx
+++ b/apps/sensenet/src/components/Icon.tsx
@@ -330,10 +330,15 @@ export const IconComponent: FunctionComponent<{
     ...defaultNotificationResolvers,
   ]
   const defaultIcon = props.defaultIcon || <WebAssetOutlined style={props.style} /> || null
-  const assignedResolver = resolvers.find((r) => (r.get(props.item, options) ? true : false))
-  if (assignedResolver) {
-    return assignedResolver.get(props.item, options)!
+
+  for (const resolver of resolvers) {
+    const icon = resolver.get(props.item, options)
+
+    if (icon) {
+      return icon
+    }
   }
+
   return defaultIcon
 }
 
diff --git a/apps/sensenet/src/components/IconFromPath.tsx b/apps/sensenet/src/components/IconFromPath.tsx
index 2528cd91c..27c280d6c 100644
--- a/apps/sensenet/src/components/IconFromPath.tsx
+++ b/apps/sensenet/src/components/IconFromPath.tsx
@@ -3,68 +3,86 @@ import React, { memo, useEffect, useMemo, useState } from 'react'
 import { IconOptions } from './Icon'
 
 // Global cache for icons
-const iconCache = new Map<string, string>()
+const iconCache = new Map<string, string | null>()
+const iconRequestCache = new Map<string, Promise<string | null>>()
 
-const IconFromPath = ({ path, options }: { path: string; options: IconOptions }) => {
-  const [icon, setIcon] = useState<string | null>(iconCache.get(path) || null)
+const loadIcon = (path: string, repo: IconOptions['repo']) => {
+  if (iconCache.has(path)) {
+    return Promise.resolve(iconCache.get(path)!)
+  }
 
-  useEffect(() => {
-    const controller = new AbortController()
-    const { signal } = controller
-
-    const fetchIcon = async () => {
-      // Check cache first
-      if (iconCache.has(path)) {
-        setIcon(iconCache.get(path)!)
-        return
-      }
+  const pendingRequest = iconRequestCache.get(path)
 
-      const imageUrl = PathHelper.joinPaths(options.repo.configuration.repositoryUrl, path)
-
-      if (path.endsWith('.svg')) {
-        try {
-          const response = await options.repo.fetch(imageUrl, { cache: 'force-cache', signal })
-          if (!response.ok) return
-          const svg = await response.text()
-          const resizedSvg = svg
-            .replace('width=', 'width="24px" oldwidth=')
-            .replace('height=', 'height="24px" oldheight=')
-          if (!signal.aborted) {
-            iconCache.set(path, resizedSvg) // Store in cache
-            setIcon(resizedSvg)
-          }
-        } catch (err) {
-          if ((err as any).name !== 'AbortError') {
-            console.error('Failed to load SVG:', err)
-          }
-        }
-      } else {
-        if (!signal.aborted) {
-          iconCache.set(path, imageUrl) // Store in cache
-          setIcon(imageUrl)
-        }
+  if (pendingRequest) {
+    return pendingRequest
+  }
+
+  const imageUrl = PathHelper.joinPaths(repo.configuration.repositoryUrl, path)
+  const request = (async () => {
+    if (!path.endsWith('.svg')) {
+      iconCache.set(path, imageUrl)
+      return imageUrl
+    }
+
+    try {
+      const response = await repo.fetch(imageUrl, { cache: 'force-cache' })
+
+      if (!response.ok) {
+        iconCache.set(path, null)
+        return null
       }
+
+      const svg = await response.text()
+      const resizedSvg = svg.replace('width=', 'width="24px" oldwidth=').replace('height=', 'height="24px" oldheight=')
+
+      iconCache.set(path, resizedSvg)
+      return resizedSvg
+    } catch {
+      iconCache.set(path, null)
+      return null
     }
+  })()
 
-    if (!icon) {
-      fetchIcon()
+  iconRequestCache.set(path, request)
+  request.finally(() => iconRequestCache.delete(path))
+
+  return request
+}
+
+const IconFromPath = ({ path, options }: { path: string; options: IconOptions }) => {
+  const { repo, style } = options
+  const [icon, setIcon] = useState<string | null>(() => iconCache.get(path) || null)
+
+  useEffect(() => {
+    let isMounted = true
+
+    if (iconCache.has(path)) {
+      setIcon(iconCache.get(path) || null)
+      return
     }
 
+    setIcon(null)
+    loadIcon(path, repo).then((loadedIcon) => {
+      if (isMounted) {
+        setIcon(loadedIcon)
+      }
+    })
+
     return () => {
-      controller.abort()
+      isMounted = false
     }
-  }, [path, options.repo, icon])
+  }, [path, repo])
 
   // Memoize the rendered output to prevent unnecessary DOM updates
   const renderedIcon = useMemo(() => {
     if (!icon) return null
 
     return path.endsWith('.svg') ? (
-      <span dangerouslySetInnerHTML={{ __html: icon }} style={options.style} aria-hidden="true" />
+      <span dangerouslySetInnerHTML={{ __html: icon }} style={style} aria-hidden="true" />
     ) : (
-      <img src={icon} alt="icon" style={options.style} />
+      <img src={icon} alt="icon" style={style} />
     )
-  }, [icon, path, options.style])
+  }, [icon, path, style])
 
   return renderedIcon
 }
diff --git a/apps/sensenet/src/components/UserAvatar.tsx b/apps/sensenet/src/components/UserAvatar.tsx
index 759318c38..ed53fdc25 100644
--- a/apps/sensenet/src/components/UserAvatar.tsx
+++ b/apps/sensenet/src/components/UserAvatar.tsx
@@ -23,7 +23,9 @@ export const UserAvatar: FC<{
   }
   return (
     <Avatar
+      {...props.avatarProps}
       style={{
+        ...props.avatarProps?.style,
         ...props.style,
       }}>
       {(props.user?.DisplayName && props.user.DisplayName[0])?.toUpperCase() ||
diff --git a/apps/sensenet/src/components/command-palette/CommandPalette.tsx b/apps/sensenet/src/components/command-palette/CommandPalette.tsx
index cc8b3d629..e4000f4aa 100644
--- a/apps/sensenet/src/components/command-palette/CommandPalette.tsx
+++ b/apps/sensenet/src/components/command-palette/CommandPalette.tsx
@@ -12,6 +12,7 @@ import { ResponsiveContext, ResponsivePersonalSettings } from '../../context'
 import { globals } from '../../globalStyles'
 import { useLocalization, useSnRoute, useTheme } from '../../hooks'
 import { CommandProviderManager } from '../../services'
+import { ContentContextMenu } from '../context-menu/content-context-menu'
 import { CommandPaletteHitsContainer } from './CommandPaletteHitsContainer'
 import { CommandPaletteSuggestion } from './CommandPaletteSuggestion'
 
@@ -71,6 +72,12 @@ export const CommandPalette = () => {
   const containerRef = useRef<HTMLDivElement>(null)
   const [delayedOpened, setDelayedOpened] = useState(false)
   const [isOpened, setIsOpened] = useState(false)
+  const [isContextMenuOpened, setIsContextMenuOpened] = useState(false)
+  const [contextMenuAnchor, setContextMenuAnchor] = useState<{ top: number; left: number }>({
+    top: 0,
+    left: 0,
+  })
+  const [contextMenuContent, setContextMenuContent] = useState<GenericContent>()
   const [items, setItems] = useState<CommandPaletteItem[]>([])
   const [inputValue, setInputValue] = useState('')
   const localization = useLocalization().commandPalette
@@ -83,6 +90,7 @@ export const CommandPalette = () => {
   const repository = useRepository()
   const cpm = useMemo(() => injector.getInstance(CommandProviderManager), [injector])
   const snRoute = useSnRoute()
+  const isContextMenuInteractingRef = useRef(false)
 
   useEffect(() => {
     const handleKeyUp = (ev: KeyboardEvent) => {
@@ -188,6 +196,23 @@ export const CommandPalette = () => {
     setIsOpened(false)
   }
 
+  const handleOpenSuggestionContextMenu = (ev: React.MouseEvent<HTMLButtonElement>, content: GenericContent) => {
+    ev.preventDefault()
+    ev.stopPropagation()
+    const buttonRect = ev.currentTarget.getBoundingClientRect()
+    isContextMenuInteractingRef.current = true
+    setContextMenuAnchor({ top: buttonRect.bottom, left: buttonRect.left })
+    setContextMenuContent(content)
+    setIsContextMenuOpened(true)
+    setIsOpened(true)
+  }
+
+  const handleCloseSuggestionContextMenu = () => {
+    isContextMenuInteractingRef.current = false
+    setIsContextMenuOpened(false)
+    setIsOpened(false)
+  }
+
   return (
     <div className={classes.buttonWrapper}>
       <div ref={containerRef} className={classes.comboBox} data-test="command-box">
@@ -210,7 +235,11 @@ export const CommandPalette = () => {
           onSuggestionsClearRequested={() => setItems([])}
           getSuggestionValue={(suggestion) => suggestion.primaryText}
           renderSuggestion={(suggestion, params) => (
-            <CommandPaletteSuggestion suggestion={suggestion} params={params} />
+            <CommandPaletteSuggestion
+              suggestion={suggestion}
+              params={params}
+              onOpenContextMenu={handleOpenSuggestionContextMenu}
+            />
           )}
           renderSuggestionsContainer={(params) => <CommandPaletteHitsContainer {...params} />}
           inputProps={{
@@ -222,7 +251,11 @@ export const CommandPalette = () => {
             },
             id: 'CommandBoxInput',
             spellCheck: false,
-            onBlur: () => setIsOpened(false),
+            onBlur: () => {
+              if (!isContextMenuInteractingRef.current) {
+                setIsOpened(false)
+              }
+            },
           }}
         />
         {!inputValue && (
@@ -246,6 +279,22 @@ export const CommandPalette = () => {
           </IconButton>
         )}
       </div>
+      {contextMenuContent ? (
+        <ContentContextMenu
+          isOpened={isContextMenuOpened}
+          content={contextMenuContent}
+          menuProps={{
+            anchorReference: 'anchorPosition',
+            anchorPosition: contextMenuAnchor,
+            BackdropProps: {
+              onClick: handleCloseSuggestionContextMenu,
+              onContextMenu: (ev: React.MouseEvent) => ev.preventDefault(),
+            },
+            disableAutoFocusItem: true,
+          }}
+          onClose={handleCloseSuggestionContextMenu}
+        />
+      ) : null}
     </div>
   )
 }
diff --git a/apps/sensenet/src/components/command-palette/CommandPaletteSuggestion.tsx b/apps/sensenet/src/components/command-palette/CommandPaletteSuggestion.tsx
index e98913628..c36bf1f19 100644
--- a/apps/sensenet/src/components/command-palette/CommandPaletteSuggestion.tsx
+++ b/apps/sensenet/src/components/command-palette/CommandPaletteSuggestion.tsx
@@ -1,13 +1,16 @@
-import { darken, Paper, useTheme } from '@material-ui/core'
+import { darken, IconButton, Paper, useTheme } from '@material-ui/core'
 import ListItem from '@material-ui/core/ListItem'
 import ListItemIcon from '@material-ui/core/ListItemIcon'
 import ListItemText from '@material-ui/core/ListItemText'
+import MoreHoriz from '@material-ui/icons/MoreHoriz'
+import { GenericContent } from '@sensenet/default-content-types'
 import match from 'autosuggest-highlight/match'
 import parse from 'autosuggest-highlight/parse'
 import React, { FunctionComponent, useContext } from 'react'
 import { RenderSuggestionParams } from 'react-autosuggest'
 import { ResponsiveContext } from '../../context'
 import { globals } from '../../globalStyles'
+import { useLocalization } from '../../hooks'
 import { Icon } from '../Icon'
 import { CommandPaletteItem } from './CommandPalette'
 
@@ -35,9 +38,13 @@ export const getMatchParts = (hits: string[], term: string, actionParams?: strin
 export const CommandPaletteSuggestion: FunctionComponent<{
   suggestion: CommandPaletteItem
   params: RenderSuggestionParams
-}> = ({ suggestion, params }) => {
+  onOpenContextMenu: (ev: React.MouseEvent<HTMLButtonElement>, content: GenericContent) => void
+}> = ({ suggestion, params, onOpenContextMenu }) => {
   const device = useContext(ResponsiveContext)
   const theme = useTheme()
+  const localization = useLocalization().commandPalette
+  const canOpenContextMenu = typeof suggestion.content?.Id !== 'undefined'
+
   return (
     <Paper>
       <ListItem
@@ -68,6 +75,20 @@ export const CommandPaletteSuggestion: FunctionComponent<{
             },
           }}
         />
+        {canOpenContextMenu ? (
+          <IconButton
+            aria-label={localization.actions}
+            title={localization.actions}
+            edge="end"
+            data-test={`search-suggestion-actions-${suggestion.content?.Name?.replace(/\s+/g, '-').toLowerCase()}`}
+            onMouseDown={(ev) => onOpenContextMenu(ev, suggestion.content!)}
+            onClick={(ev) => {
+              ev.preventDefault()
+              ev.stopPropagation()
+            }}>
+            <MoreHoriz />
+          </IconButton>
+        ) : null}
       </ListItem>
     </Paper>
   )
diff --git a/apps/sensenet/src/components/content/AUIApplicationView.tsx b/apps/sensenet/src/components/content/AUIApplicationView.tsx
new file mode 100644
index 000000000..30132aeb0
--- /dev/null
+++ b/apps/sensenet/src/components/content/AUIApplicationView.tsx
@@ -0,0 +1,376 @@
+import { CircularProgress, createStyles, makeStyles, Theme, Typography } from '@material-ui/core'
+import { ODataFieldParameter } from '@sensenet/client-core'
+import { GenericContent } from '@sensenet/default-content-types'
+import { CurrentContentContext, useLogger, useRepository } from '@sensenet/hooks-react'
+import React, { useContext, useEffect, useMemo, useRef, useState } from 'react'
+
+export const AUI_APPLICATION_CONTENT_TYPE = 'AUIApplication'
+
+type AUIApplicationContent = GenericContent & {
+  Html?: string
+}
+
+type AUIApplicationBridgeFetchInit = {
+  method?: string
+  headers?: Record<string, string>
+  body?: string
+}
+
+type AUIApplicationBridgeFetchRequest = {
+  source: typeof AUI_APPLICATION_CONTENT_TYPE
+  type: 'fetch'
+  requestId: string
+  input: string
+  init?: AUIApplicationBridgeFetchInit
+}
+
+const makeSafeScriptJson = (value: unknown) => JSON.stringify(value).replace(/</g, '\\u003c')
+
+const escapeAttribute = (value: string) =>
+  value.replace(/&/g, '&amp;').replace(/"/g, '&quot;').replace(/</g, '&lt;').replace(/>/g, '&gt;')
+
+const getApplicationBaseUrl = (repositoryUrl: string, contentPath: string) => {
+  const baseRepositoryUrl = repositoryUrl.replace(/\/+$/, '')
+  const normalizedContentPath = contentPath.replace(/^\/+/, '').replace(/\/+$/, '')
+
+  return `${baseRepositoryUrl}/${normalizedContentPath}/`
+}
+
+const getRepositoryRequestUrl = (repositoryUrl: string, input: string) => {
+  const baseRepositoryUrl = repositoryUrl.replace(/\/+$/, '')
+  const repositoryOrigin = new URL(baseRepositoryUrl).origin
+  const requestUrl = new URL(input, `${baseRepositoryUrl}/`)
+
+  if (requestUrl.origin !== repositoryOrigin) {
+    throw new Error('AUIApplication requests are only allowed against the current repository.')
+  }
+
+  return requestUrl.toString()
+}
+
+const getBridgeRequestInit = (init?: AUIApplicationBridgeFetchInit): RequestInit => {
+  const headers = new Headers(init?.headers)
+
+  return {
+    method: init?.method || 'GET',
+    credentials: 'include',
+    headers,
+    body: init?.body,
+  }
+}
+
+const createApplicationDocument = (
+  html: string,
+  repositoryUrl: string,
+  adminUiUrl: string,
+  content: AUIApplicationContent | undefined,
+) => {
+  const baseUrl = getApplicationBaseUrl(repositoryUrl, content?.Path ?? '')
+  const bootstrap = `<base href="${escapeAttribute(baseUrl)}">
+<meta charset="utf-8">
+<script>
+(() => {
+  const pendingFetches = new Map();
+
+  const normalizeHeaders = (headers) => {
+    if (!headers) {
+      return {};
+    }
+
+    if (typeof headers.forEach === 'function') {
+      const normalizedHeaders = {};
+      headers.forEach((value, key) => {
+        normalizedHeaders[key] = value;
+      });
+      return normalizedHeaders;
+    }
+
+    if (Array.isArray(headers)) {
+      return headers.reduce((normalizedHeaders, header) => {
+        normalizedHeaders[header[0]] = header[1];
+        return normalizedHeaders;
+      }, {});
+    }
+
+    return headers;
+  };
+
+  const createBridgeResponse = (response) => ({
+    ok: response.ok,
+    status: response.status,
+    statusText: response.statusText,
+    url: response.url,
+    headers: {
+      get: (name) => response.headers[String(name).toLowerCase()] || null,
+      entries: () => Object.entries(response.headers),
+    },
+    text: () => Promise.resolve(response.body),
+    json: () => Promise.resolve(JSON.parse(response.body)),
+  });
+
+  window.addEventListener('message', (event) => {
+    const data = event.data || {};
+
+    if (data.source !== ${makeSafeScriptJson(AUI_APPLICATION_CONTENT_TYPE)} || !data.requestId) {
+      return;
+    }
+
+    const pendingFetch = pendingFetches.get(data.requestId);
+
+    if (!pendingFetch) {
+      return;
+    }
+
+    pendingFetches.delete(data.requestId);
+
+    if (data.type === 'fetch:error') {
+      pendingFetch.reject(new Error(data.error || 'AUIApplication fetch failed.'));
+      return;
+    }
+
+    pendingFetch.resolve(createBridgeResponse(data.response));
+  });
+
+  window.sensenetAdminApp = {
+    repositoryUrl: ${makeSafeScriptJson(repositoryUrl)},
+    adminUiUrl: ${makeSafeScriptJson(adminUiUrl)},
+    content: ${makeSafeScriptJson({
+      Id: content?.Id,
+      Path: content?.Path,
+      Name: content?.Name,
+      DisplayName: content?.DisplayName,
+      Type: content?.Type,
+    })},
+    fetch: (input, init = {}) => {
+      const requestId = \`\${Date.now()}-\${Math.random().toString(36).slice(2)}\`;
+
+      return new Promise((resolve, reject) => {
+        pendingFetches.set(requestId, { resolve, reject });
+        window.parent.postMessage(
+          {
+            source: ${makeSafeScriptJson(AUI_APPLICATION_CONTENT_TYPE)},
+            type: 'fetch',
+            requestId,
+            input,
+            init: {
+              method: init.method,
+              headers: normalizeHeaders(init.headers),
+              body: typeof init.body === 'string' ? init.body : undefined,
+            },
+          },
+          '*',
+        );
+      });
+    },
+  };
+})();
+</script>`
+
+  if (/<head[\s>]/i.test(html)) {
+    return html.replace(/<head([^>]*)>/i, `<head$1>\n${bootstrap}`)
+  }
+
+  if (/<html[\s>]/i.test(html)) {
+    return html.replace(/<html([^>]*)>/i, `<html$1>\n<head>${bootstrap}</head>`)
+  }
+
+  return `<!doctype html>
+<html>
+  <head>
+    ${bootstrap}
+    <style>
+      html,
+      body {
+        margin: 0;
+        min-height: 100%;
+      }
+    </style>
+  </head>
+  <body>${html}</body>
+</html>`
+}
+
+const useStyles = makeStyles((theme: Theme) =>
+  createStyles({
+    wrapper: {
+      flex: '1 1 auto',
+      minHeight: 0,
+      width: '100%',
+      backgroundColor: theme.palette.background.default,
+    },
+    frame: {
+      width: '100%',
+      height: '100%',
+      display: 'block',
+      border: 0,
+      backgroundColor: '#fff',
+    },
+    status: {
+      height: '100%',
+      display: 'flex',
+      alignItems: 'center',
+      justifyContent: 'center',
+      gap: theme.spacing(2),
+      color: theme.palette.text.secondary,
+    },
+  }),
+)
+
+export const AUIApplicationView: React.FC = () => {
+  const classes = useStyles()
+  const frameRef = useRef<HTMLIFrameElement>(null)
+  const repository = useRepository()
+  const logger = useLogger('AUIApplicationView')
+  const currentContent = useContext(CurrentContentContext) as AUIApplicationContent
+  const [content, setContent] = useState<AUIApplicationContent>()
+  const [isLoading, setIsLoading] = useState(false)
+  const [hasError, setHasError] = useState(false)
+  const idOrPath = currentContent.Id || currentContent.Path
+
+  useEffect(() => {
+    const abortController = new AbortController()
+
+    if (!idOrPath) {
+      setContent(undefined)
+      return () => abortController.abort()
+    }
+
+    setIsLoading(true)
+    setHasError(false)
+    ;(async () => {
+      try {
+        const response = await repository.load<AUIApplicationContent>({
+          idOrPath,
+          requestInit: { signal: abortController.signal },
+          oDataOptions: {
+            select: ['Id', 'Path', 'Name', 'DisplayName', 'Type', 'Html'] as ODataFieldParameter<AUIApplicationContent>,
+          },
+        })
+
+        if (!abortController.signal.aborted) {
+          setContent(response.d)
+        }
+      } catch (error) {
+        if (!abortController.signal.aborted) {
+          setHasError(true)
+          logger.error({
+            message: 'Failed to load AUIApplication content.',
+            data: { error, relatedContent: currentContent },
+          })
+        }
+      } finally {
+        if (!abortController.signal.aborted) {
+          setIsLoading(false)
+        }
+      }
+    })()
+
+    return () => abortController.abort()
+  }, [currentContent, idOrPath, logger, repository])
+
+  useEffect(() => {
+    const handleBridgeMessage = async (event: MessageEvent<AUIApplicationBridgeFetchRequest>) => {
+      if (event.source !== frameRef.current?.contentWindow) {
+        return
+      }
+
+      const { data } = event
+
+      if (data?.source !== AUI_APPLICATION_CONTENT_TYPE || data.type !== 'fetch' || !data.requestId || !data.input) {
+        return
+      }
+
+      const postResponse = (message: Record<string, unknown>) => {
+        frameRef.current?.contentWindow?.postMessage(
+          {
+            source: AUI_APPLICATION_CONTENT_TYPE,
+            requestId: data.requestId,
+            ...message,
+          },
+          '*',
+        )
+      }
+
+      try {
+        const requestUrl = getRepositoryRequestUrl(repository.configuration.repositoryUrl, data.input)
+        const response = await repository.fetch(requestUrl, getBridgeRequestInit(data.init))
+        const headers: Record<string, string> = {}
+
+        response.headers.forEach((value, key) => {
+          headers[key.toLowerCase()] = value
+        })
+
+        postResponse({
+          type: 'fetch:success',
+          response: {
+            ok: response.ok,
+            status: response.status,
+            statusText: response.statusText,
+            url: response.url,
+            headers,
+            body: await response.text(),
+          },
+        })
+      } catch (error) {
+        postResponse({
+          type: 'fetch:error',
+          error: error instanceof Error ? error.message : String(error),
+        })
+      }
+    }
+
+    window.addEventListener('message', handleBridgeMessage)
+
+    return () => window.removeEventListener('message', handleBridgeMessage)
+  }, [repository])
+
+  const applicationHtml = content?.Html?.trim() ?? ''
+  const adminUiUrl = window.location.origin
+  const srcDoc = useMemo(
+    () => createApplicationDocument(applicationHtml, repository.configuration.repositoryUrl, adminUiUrl, content),
+    [adminUiUrl, applicationHtml, content, repository.configuration.repositoryUrl],
+  )
+
+  if (isLoading) {
+    return (
+      <div className={classes.wrapper}>
+        <div className={classes.status}>
+          <CircularProgress size={24} />
+          <Typography>Loading application...</Typography>
+        </div>
+      </div>
+    )
+  }
+
+  if (hasError) {
+    return (
+      <div className={classes.wrapper}>
+        <div className={classes.status}>
+          <Typography>Failed to load application HTML.</Typography>
+        </div>
+      </div>
+    )
+  }
+
+  if (!applicationHtml) {
+    return (
+      <div className={classes.wrapper}>
+        <div className={classes.status}>
+          <Typography>This AUIApplication does not contain HTML yet.</Typography>
+        </div>
+      </div>
+    )
+  }
+
+  return (
+    <div className={classes.wrapper}>
+      <iframe
+        ref={frameRef}
+        className={classes.frame}
+        title={content?.DisplayName || currentContent.DisplayName || AUI_APPLICATION_CONTENT_TYPE}
+        sandbox="allow-downloads allow-forms allow-modals allow-popups allow-scripts allow-top-navigation-by-user-activation"
+        srcDoc={srcDoc}
+      />
+    </div>
+  )
+}
diff --git a/apps/sensenet/src/components/content/ContentInfo.tsx b/apps/sensenet/src/components/content/ContentInfo.tsx
index cf85e0b3f..213ceadf3 100644
--- a/apps/sensenet/src/components/content/ContentInfo.tsx
+++ b/apps/sensenet/src/components/content/ContentInfo.tsx
@@ -2,7 +2,7 @@ import { Button, ListItemIcon, makeStyles, Theme } from '@material-ui/core'
 import { ActionModel, GenericContent, isActionModel } from '@sensenet/default-content-types'
 import { CurrentContentContext, useLogger, useWopi } from '@sensenet/hooks-react'
 import React, { useCallback, useContext, useEffect, useState } from 'react'
-import { useLoadContent } from '../../hooks'
+import { useLoadContent, useLocalization } from '../../hooks'
 import { contextMenuODataOptions } from '../context-menu/context-menu-odata-options'
 import { getIcon } from '../context-menu/icons'
 import { useContextMenuActions } from '../context-menu/use-context-menu-actions'
@@ -19,6 +19,7 @@ export function ContentInfo() {
     isOpened: true,
   })
   const { isWriteAvailable } = useWopi()
+  const oDataActionsTitle = useLocalization().customActions.oDataActionsDialog.menuTitle
 
   const setActionsWopi = useCallback(
     (contentFromCallback: GenericContent) => {
@@ -77,6 +78,16 @@ export function ContentInfo() {
           <span> {parentContent.Path}</span>
         </div>
         <div className="buttonPanel">
+          <Button
+            key="ODataActions"
+            title={oDataActionsTitle}
+            disableRipple={true}
+            onClick={() => {
+              runAction('ODataActions')
+            }}>
+            <ListItemIcon>{getIcon('odataactions')}</ListItemIcon>
+            <div style={{ flexGrow: 1 }}>{oDataActionsTitle}</div>
+          </Button>
           {actions
             ?.filter((a: ActionModel) => {
               return a.Name !== 'Share' && a.Name !== 'Delete' && a.Name !== 'Browse'
diff --git a/apps/sensenet/src/components/content/Explore.tsx b/apps/sensenet/src/components/content/Explore.tsx
index ffbb9fa23..90b955386 100644
--- a/apps/sensenet/src/components/content/Explore.tsx
+++ b/apps/sensenet/src/components/content/Explore.tsx
@@ -5,6 +5,7 @@ import { GenericContent } from '@sensenet/default-content-types'
 import {
   CurrentAncestorsProvider,
   CurrentChildrenProvider,
+  CurrentContentContext,
   CurrentContentProvider,
   LoadSettingsContextProvider,
   useRepository,
@@ -12,7 +13,7 @@ import {
 import { ColumnSetting } from '@sensenet/list-controls-react/src/ContentList/content-list-base-props'
 import { ColDef } from 'ag-grid-community'
 import { clsx } from 'clsx'
-import React, { useContext, useRef, useState } from 'react'
+import React, { useContext, useMemo, useRef, useState } from 'react'
 import { useHistory } from 'react-router'
 import { GridKeyEnum } from '../../../src/components/grid/enums/GridKey.enum'
 import { ResponsivePersonalSettings } from '../../context'
@@ -26,8 +27,45 @@ import { Grid } from '../grid/Grid'
 import { SimpleTree } from '../tree/simpletree'
 import { BrowseView, EditView, ImageView, NewView, PermissionView, VersionView } from '../view-controls'
 import WopiPage from '../wopi-page'
+import { AUI_APPLICATION_CONTENT_TYPE, AUIApplicationView } from './AUIApplicationView'
 import { ContentInfo } from './ContentInfo'
 
+const requiredGridLoadFields: ODataFieldParameter<GenericContent> = [
+  'Id',
+  'ParentId',
+  'Path',
+  'Name',
+  'DisplayName',
+  'Type',
+  'Icon',
+  'IsFolder',
+  'IsFile',
+  'Actions',
+  'CreatedBy',
+  'CreationDate',
+  'ModifiedBy',
+  'ModificationDate',
+  'Index',
+  'Locked',
+]
+
+const getGridLoadChildrenSettings = (colDef: ColDef[]): ODataParams<GenericContent> => {
+  const selectFields = new Set<keyof GenericContent>(requiredGridLoadFields)
+
+  colDef.forEach((columnDefinition) => {
+    if (columnDefinition.field && columnDefinition.field !== '0') {
+      selectFields.add(columnDefinition.field as keyof GenericContent)
+    }
+  })
+
+  return {
+    orderby: [['DisplayName', 'asc']],
+    select: Array.from(selectFields),
+    expand: ['CreatedBy', 'ModifiedBy'],
+    onlyselectList: true,
+  }
+}
+
 const useStyles = makeStyles<Theme, { width: number }>((theme) =>
   createStyles({
     breadcrumbsWrapper: {
@@ -129,6 +167,51 @@ export type ExploreProps = {
   gridKey: GridKeyEnum
 }
 
+type ExploreGridOrApplicationProps = {
+  currentPath: string
+  fieldsToDisplay?: Array<ColumnSetting<GenericContent>>
+  schema?: string
+  disableColumnSettings?: boolean
+  colDef: ColDef[]
+  gridKey: GridKeyEnum
+  onNavigate: (content: GenericContent) => void
+  onActivateItem: (activeItem: GenericContent) => Promise<void>
+}
+
+const ExploreGridOrApplication: React.FC<ExploreGridOrApplicationProps> = ({
+  currentPath,
+  fieldsToDisplay,
+  schema,
+  disableColumnSettings,
+  colDef,
+  gridKey,
+  onNavigate,
+  onActivateItem,
+}) => {
+  const selectionService = useSelectionService()
+  const currentContent = useContext(CurrentContentContext)
+
+  if (currentContent.Type === AUI_APPLICATION_CONTENT_TYPE) {
+    return <AUIApplicationView />
+  }
+
+  return (
+    <Grid
+      disableColumnSettings={disableColumnSettings}
+      style={{ flexGrow: 7, flexShrink: 0, maxHeight: '100%' }}
+      enableBreadcrumbs={false}
+      fieldsToDisplay={fieldsToDisplay}
+      schema={schema}
+      onParentChange={onNavigate}
+      onActivateItem={onActivateItem}
+      onActiveItemChange={(item) => selectionService.activeContent.setValue(item)}
+      parentIdOrPath={currentPath}
+      colDef={colDef}
+      gridKey={gridKey}
+    />
+  )
+}
+
 export function Explore({
   currentPath,
   onNavigate,
@@ -145,7 +228,6 @@ export function Explore({
   gridKey,
 }: ExploreProps) {
   const theme = useTheme()
-  const selectionService = useSelectionService()
   const [width, setWidth] = useState<number>(Number(localStorage.getItem('treeWidth') ?? '400'))
   const classes = useStyles({ width })
   const globalClasses = useGlobalStyles()
@@ -186,6 +268,10 @@ export function Explore({
   const pathFromUrl = useQuery().get('path')
   const snRoute = useSnRoute()
   const activeAction = snRoute.match!.params.action
+  const currentChildrenLoadSettings = useMemo(
+    () => loadChildrenSettings || getGridLoadChildrenSettings(colDef),
+    [colDef, loadChildrenSettings],
+  )
   const onActivateItemOverride = async (activeItem: GenericContent) => {
     const expandedItem = await repository.load({
       idOrPath: activeItem.Id,
@@ -255,16 +341,13 @@ export function Explore({
       <>
         {renderBeforeGrid?.()}
         <ContentInfo />
-        <Grid
+        <ExploreGridOrApplication
           disableColumnSettings={disableColumnSettings}
-          style={{ flexGrow: 7, flexShrink: 0, maxHeight: '100%' }}
-          enableBreadcrumbs={false}
           fieldsToDisplay={fieldsToDisplay}
           schema={schema}
-          onParentChange={onNavigate}
+          onNavigate={onNavigate}
           onActivateItem={onActivateItemOverride}
-          onActiveItemChange={(item) => selectionService.activeContent.setValue(item)}
-          parentIdOrPath={currentPath}
+          currentPath={currentPath}
           colDef={colDef}
           gridKey={gridKey}
         />
@@ -273,7 +356,9 @@ export function Explore({
   }
 
   return (
-    <LoadSettingsContextProvider>
+    <LoadSettingsContextProvider
+      key={JSON.stringify(currentChildrenLoadSettings)}
+      loadChildrenSettings={currentChildrenLoadSettings}>
       <CurrentContentProvider idOrPath={currentPath}>
         <CurrentChildrenProvider loadSettings={loadChildrenSettings} alwaysRefresh={alwaysRefreshChildren}>
           <CurrentAncestorsProvider root={rootPath}>
diff --git a/apps/sensenet/src/components/context-menu/content-context-menu.tsx b/apps/sensenet/src/components/context-menu/content-context-menu.tsx
index 38dd7210f..6013d9157 100644
--- a/apps/sensenet/src/components/context-menu/content-context-menu.tsx
+++ b/apps/sensenet/src/components/context-menu/content-context-menu.tsx
@@ -9,7 +9,7 @@ import { ActionModel, GenericContent, isActionModel } from '@sensenet/default-co
 import { useLogger, useWopi } from '@sensenet/hooks-react'
 import React, { useCallback, useContext, useEffect, useState } from 'react'
 import { ResponsiveContext } from '../../context'
-import { useLoadContent } from '../../hooks'
+import { useLoadContent, useLocalization } from '../../hooks'
 import { contextMenuODataOptions } from './context-menu-odata-options'
 import { getIcon } from './icons'
 import { useContextMenuActions } from './use-context-menu-actions'
@@ -64,13 +64,18 @@ export const ContentContextMenu: React.FunctionComponent<ContentContextMenuProps
 
   const { runAction } = useContextMenuActions(props.content, setActionsWopi)
   const device = useContext(ResponsiveContext)
+  const oDataActionsTitle = useLocalization().customActions.oDataActionsDialog.menuTitle
+  const runODataActions = () => {
+    props.onClose?.()
+    runAction('ODataActions')
+  }
 
   useEffect(() => {
     if (content) {
       setActionsWopi(content)
     }
   }, [content, setActionsWopi])
-  return !actions?.length ? null : (
+  return (
     <div onKeyDown={(ev) => ev.stopPropagation()} onKeyPress={(ev) => ev.stopPropagation()}>
       {device === 'mobile' ? (
         <Drawer
@@ -80,6 +85,10 @@ export const ContentContextMenu: React.FunctionComponent<ContentContextMenuProps
           open={props.isOpened}
           PaperProps={{ style: { paddingBottom: '2em' } }}>
           <List>
+            <ListItem onClick={runODataActions}>
+              <ListItemIcon>{getIcon('odataactions')}</ListItemIcon>
+              <ListItemText primary={oDataActionsTitle} />
+            </ListItem>
             {actions?.map((action) => {
               return (
                 <ListItem
@@ -98,6 +107,14 @@ export const ContentContextMenu: React.FunctionComponent<ContentContextMenuProps
         </Drawer>
       ) : (
         <Menu open={props.isOpened} {...props.menuProps} data-test="content-context-menu-root">
+          <MenuItem
+            key="ODataActions"
+            disableRipple={true}
+            data-test="content-context-menu-odata-actions"
+            onClick={runODataActions}>
+            <ListItemIcon>{getIcon('odataactions')}</ListItemIcon>
+            <div style={{ flexGrow: 1 }}>{oDataActionsTitle}</div>
+          </MenuItem>
           {actions?.map((action) => {
             return (
               <MenuItem
diff --git a/apps/sensenet/src/components/context-menu/use-context-menu-actions.ts b/apps/sensenet/src/components/context-menu/use-context-menu-actions.ts
index efc499dc6..b8b44f723 100644
--- a/apps/sensenet/src/components/context-menu/use-context-menu-actions.ts
+++ b/apps/sensenet/src/components/context-menu/use-context-menu-actions.ts
@@ -204,6 +204,15 @@ export function useContextMenuActions(content: GenericContent, setActions: (cont
           },
         })
         break
+      case 'ODataActions':
+        openDialog({
+          name: 'odata-actions',
+          props: {
+            content,
+          },
+          dialogProps: { classes: { paper: globalClasses.pickerDialog } },
+        })
+        break
       /*Az az új hozzáállás, hogy ha nem találja meg az action-t akkor jöjjön be az operation kezelő.
         Ezt majd le kell!! cserélni úgy, hogy vizsgálva legyen a Type-ja*/
       default:
diff --git a/apps/sensenet/src/components/dialogs/dialog-provider.tsx b/apps/sensenet/src/components/dialogs/dialog-provider.tsx
index c5419cc20..61469100a 100644
--- a/apps/sensenet/src/components/dialogs/dialog-provider.tsx
+++ b/apps/sensenet/src/components/dialogs/dialog-provider.tsx
@@ -14,6 +14,7 @@ import {
   DeleteContentDialogProps,
   ExecuteActionDialogProps,
   OperationsDialogProps,
+  ODataActionsDialogProps,
   PermissionEditorDialogProps,
   ReferenceContentListProps,
   RestoreProps,
@@ -26,6 +27,7 @@ export type DialogWithProps = (
   | { name: 'error'; props: ErrorBoundaryState }
   | { name: 'copy-move'; props: CopyMoveDialogProps }
   | { name: 'operation'; props: OperationsDialogProps }
+  | { name: 'odata-actions'; props: ODataActionsDialogProps }
   | { name: 'check-in'; props: CheckInProps }
   | { name: 'are-you-sure'; props: AreYouSureProps }
   | { name: 'approve'; props: ApproveProps }
diff --git a/apps/sensenet/src/components/dialogs/dialogs.tsx b/apps/sensenet/src/components/dialogs/dialogs.tsx
index 81e6fad2d..916982cdf 100644
--- a/apps/sensenet/src/components/dialogs/dialogs.tsx
+++ b/apps/sensenet/src/components/dialogs/dialogs.tsx
@@ -25,6 +25,7 @@ const DateRangePicker = lazy(() => import('./date-range-picker'))
 const AddDeleteUserGroups = lazy(() => import('./add-delete-user-groups'))
 const ColumnSettings = lazy(() => import('./column-settings'))
 const Operations = lazy(() => import('./operations/operations'))
+const ODataActions = lazy(() => import('./odata-actions'))
 
 function dialogRenderer(dialog: DialogWithProps) {
   switch (dialog.name) {
@@ -72,6 +73,8 @@ function dialogRenderer(dialog: DialogWithProps) {
       return <ColumnSettings {...dialog.props} />
     case 'operation':
       return <Operations {...dialog.props} />
+    case 'odata-actions':
+      return <ODataActions {...dialog.props} />
     default:
       return null
   }
diff --git a/apps/sensenet/src/components/dialogs/execute-action.tsx b/apps/sensenet/src/components/dialogs/execute-action.tsx
index d869f817f..61d5ea8c0 100644
--- a/apps/sensenet/src/components/dialogs/execute-action.tsx
+++ b/apps/sensenet/src/components/dialogs/execute-action.tsx
@@ -3,7 +3,6 @@ import DialogActions from '@material-ui/core/DialogActions'
 import DialogContent from '@material-ui/core/DialogContent'
 import LinearProgress from '@material-ui/core/LinearProgress'
 import Typography from '@material-ui/core/Typography'
-import { PathHelper } from '@sensenet/client-utils'
 import { useInjector, useLogger, useRepository } from '@sensenet/hooks-react'
 import React, { lazy, useEffect, useState } from 'react'
 import { useGlobalStyles } from '../../globalStyles'
@@ -12,6 +11,7 @@ import {
   CustomActionCommandProvider,
   OnExecuteActionPayload,
 } from '../../services/CommandProviders/CustomActionCommandProvider'
+import { executeCustomAction } from '../../services/execute-custom-action'
 import { createCustomActionModel } from '../../services/MonacoModels/create-custom-action-model'
 import { getMonacoModelUri } from '../editor/text-editor'
 import { DialogTitle, useDialog } from '.'
@@ -55,38 +55,7 @@ export function ExecuteActionDialog({ actionValue }: ExecuteActionDialogProps) {
     setIsExecuting(true)
     setError('')
     try {
-      switch (actionValue.action.Name) {
-        case 'Load':
-          return await repo.load({ idOrPath: actionValue.content.Id, oDataOptions: { select: 'all' } })
-        case 'LoadCollection':
-          return await repo.loadCollection({ path: actionValue.content.Path })
-        case 'Create': {
-          const parsedBody = JSON.parse(postBody) as { contentType: string; content: object }
-          return await repo.post({
-            contentType: parsedBody.contentType,
-            parentPath: actionValue.content.IsFolder
-              ? actionValue.content.Path
-              : PathHelper.getParentPath(actionValue.content.Path),
-            content: parsedBody.content,
-          })
-        }
-        case 'Remove': {
-          const { permanent } = JSON.parse(postBody)
-          return await repo.delete({
-            idOrPath: actionValue.content.Id,
-            permanent: permanent == null ? false : permanent,
-          })
-        }
-        case 'Update':
-          return await repo.patch({ idOrPath: actionValue.content.Id, content: JSON.parse(postBody).content })
-        default:
-          return await repo.executeAction({
-            idOrPath: actionValue.content.Id,
-            body: JSON.parse(postBody),
-            method: actionValue.method,
-            name: actionValue.action.Name,
-          })
-      }
+      return await executeCustomAction(repo, actionValue, postBody)
     } catch (e) {
       setError(e.message)
       logger.error({
diff --git a/apps/sensenet/src/components/dialogs/odata-actions.tsx b/apps/sensenet/src/components/dialogs/odata-actions.tsx
new file mode 100644
index 000000000..9f2f795e6
--- /dev/null
+++ b/apps/sensenet/src/components/dialogs/odata-actions.tsx
@@ -0,0 +1,275 @@
+import {
+  Button,
+  DialogActions,
+  DialogContent,
+  FormControl,
+  InputLabel,
+  LinearProgress,
+  MenuItem,
+  Select,
+  Typography,
+} from '@material-ui/core'
+import { GenericContent } from '@sensenet/default-content-types'
+import { useInjector, useLogger, useRepository } from '@sensenet/hooks-react'
+import React, { lazy, useEffect, useMemo, useState } from 'react'
+import { useGlobalStyles } from '../../globalStyles'
+import { useLocalization, useTheme } from '../../hooks'
+import {
+  CustomActionCommandProvider,
+  OnExecuteActionPayload,
+} from '../../services/CommandProviders/CustomActionCommandProvider'
+import { executeCustomAction } from '../../services/execute-custom-action'
+import { createCustomActionModel } from '../../services/MonacoModels/create-custom-action-model'
+import { getMonacoModelUri } from '../editor/text-editor'
+import { DialogTitle, useDialog } from '.'
+
+const MonacoEditor = lazy(() => import('react-monaco-editor'))
+
+const EDITOR_INITIAL_VALUE = `{
+
+}`
+
+export type ODataActionsDialogProps = {
+  content: GenericContent
+}
+
+export function ODataActionsDialog({ content }: ODataActionsDialogProps) {
+  const theme = useTheme()
+  const { closeLastDialog, openDialog } = useDialog()
+  const localization = useLocalization().customActions.oDataActionsDialog
+  const customActionService = useInjector().getInstance(CustomActionCommandProvider)
+  const logger = useLogger('ODataActions')
+  const repo = useRepository()
+  const globalClasses = useGlobalStyles()
+
+  const [actions, setActions] = useState<OnExecuteActionPayload[]>([])
+  const [selectedActionIndex, setSelectedActionIndex] = useState('')
+  const [postBody, setPostBody] = useState(EDITOR_INITIAL_VALUE)
+  const [uri, setUri] = useState<import('react-monaco-editor').monaco.Uri>()
+  const [isLoading, setIsLoading] = useState(false)
+  const [isExecuting, setIsExecuting] = useState(false)
+  const [error, setError] = useState('')
+
+  const selectedAction = useMemo(() => {
+    if (selectedActionIndex === '') {
+      return undefined
+    }
+
+    return actions[Number(selectedActionIndex)]
+  }, [actions, selectedActionIndex])
+
+  useEffect(() => {
+    let isMounted = true
+
+    setIsLoading(true)
+    setError('')
+    ;(async () => {
+      try {
+        const oDataActions = await customActionService.getODataActionPayloads(content, repo)
+
+        if (!isMounted) {
+          return
+        }
+
+        setActions(oDataActions)
+        setSelectedActionIndex(oDataActions.length ? '0' : '')
+      } catch (loadError) {
+        if (!isMounted) {
+          return
+        }
+
+        setError(loadError instanceof Error ? loadError.message : localization.loadError)
+        logger.error({
+          message: localization.loadError,
+          data: { error: loadError, relatedContent: content, relatedRepository: repo.configuration.repositoryUrl },
+        })
+      } finally {
+        if (isMounted) {
+          setIsLoading(false)
+        }
+      }
+    })()
+
+    return () => {
+      isMounted = false
+    }
+  }, [content, customActionService, localization.loadError, logger, repo])
+
+  useEffect(() => {
+    let isMounted = true
+
+    setPostBody(EDITOR_INITIAL_VALUE)
+    setError('')
+    setUri(undefined)
+
+    if (!selectedAction) {
+      return () => {
+        isMounted = false
+      }
+    }
+
+    ;(async () => {
+      const nextUri = await getMonacoModelUri(selectedAction.content, repo, selectedAction.action)
+
+      if (isMounted) {
+        setUri(nextUri)
+      }
+    })()
+
+    return () => {
+      isMounted = false
+    }
+  }, [repo, selectedAction])
+
+  useEffect(() => {
+    if (uri && selectedAction?.metadata) {
+      createCustomActionModel(uri, selectedAction.metadata)
+    }
+  }, [uri, selectedAction])
+
+  const executeSelectedAction = async () => {
+    if (!selectedAction) {
+      return
+    }
+
+    setIsExecuting(true)
+    setError('')
+
+    try {
+      const result = await executeCustomAction(repo, selectedAction, postBody)
+      const response = JSON.stringify(
+        {
+          content: {
+            Id: selectedAction.content.Id,
+            Path: selectedAction.content.Path,
+            Name: selectedAction.content.Name,
+          },
+          action: selectedAction.action.Name,
+          response: result,
+        },
+        undefined,
+        3,
+      )
+
+      logger.information({
+        message: `OData action executed: '${selectedAction.action.DisplayName || selectedAction.action.Name}'`,
+        data: {
+          relatedContent: selectedAction.content,
+          relatedRepository: repo.configuration.repositoryUrl,
+          details: { actionValue: selectedAction, result },
+        },
+      })
+
+      closeLastDialog()
+      openDialog({ name: 'custom-action-result', props: { response } })
+    } catch (executeError) {
+      setError(executeError instanceof Error ? executeError.message : String(executeError))
+      logger.error({
+        message: `There was an error executing OData action '${
+          selectedAction.action.DisplayName || selectedAction.action.Name
+        }'`,
+        data: {
+          isDismissed: true,
+          relatedRepository: repo.configuration.repositoryUrl,
+          relatedContent: selectedAction.content,
+          error: executeError,
+          details: { actionValue: selectedAction },
+        },
+      })
+    } finally {
+      setIsExecuting(false)
+    }
+  }
+
+  return (
+    <>
+      <DialogTitle>
+        {localization.title.replace('{0}', content.DisplayName || content.Name || content.Path || '')}
+      </DialogTitle>
+      <DialogContent style={{ overflow: 'hidden' }}>
+        {isLoading ? (
+          <>
+            <Typography>{localization.loadingActions}</Typography>
+            <LinearProgress />
+          </>
+        ) : !actions.length ? (
+          <Typography>{error || localization.noActions}</Typography>
+        ) : (
+          <>
+            <FormControl fullWidth style={{ marginBottom: '1.5em' }}>
+              <InputLabel id="odata-action-select-label">{localization.actionLabel}</InputLabel>
+              <Select
+                labelId="odata-action-select-label"
+                value={selectedActionIndex}
+                onChange={(event) => setSelectedActionIndex(event.target.value as string)}>
+                {actions.map((actionValue, index) => (
+                  <MenuItem key={actionValue.action.OpId || actionValue.action.Name} value={String(index)}>
+                    {actionValue.action.DisplayName || actionValue.action.Name}
+                  </MenuItem>
+                ))}
+              </Select>
+            </FormControl>
+
+            {isExecuting ? (
+              <>
+                <Typography>{localization.executingAction}</Typography>
+                <LinearProgress />
+              </>
+            ) : selectedAction?.metadata?.parameters?.length && uri ? (
+              <>
+                <Typography style={{ marginBottom: '0.5em' }}>{localization.parameters}</Typography>
+                <MonacoEditor
+                  key={uri.toString()}
+                  height={320}
+                  theme={theme.palette.type === 'dark' ? 'vs-dark' : 'vs-light'}
+                  width="100%"
+                  language="json"
+                  value={postBody}
+                  onChange={(value) => setPostBody(value)}
+                  options={{
+                    automaticLayout: true,
+                    minimap: { enabled: false },
+                    lineNumbers: 'off',
+                  }}
+                  editorDidMount={(editor, monaco) => {
+                    if (!uri) {
+                      return
+                    }
+                    const model = monaco.editor.getModel(uri)
+                    if (!model) {
+                      const createdModel = monaco.editor.createModel(postBody, 'json', uri)
+                      editor.setModel(createdModel)
+                    } else {
+                      editor.setModel(model)
+                      setPostBody(model.getValue())
+                    }
+                  }}
+                />
+              </>
+            ) : (
+              <Typography>{localization.noParameters}</Typography>
+            )}
+          </>
+        )}
+      </DialogContent>
+      <DialogActions>
+        <div style={{ flex: 1, marginLeft: '1.5em' }}>
+          {error && actions.length ? <Typography color="error">{error}</Typography> : null}
+        </div>
+        <Button aria-label={localization.cancelButton} className={globalClasses.cancelButton} onClick={closeLastDialog}>
+          {localization.cancelButton}
+        </Button>
+        <Button
+          aria-label={localization.executeButton}
+          color="primary"
+          variant="contained"
+          disabled={!selectedAction || isLoading || isExecuting}
+          onClick={executeSelectedAction}>
+          {localization.executeButton}
+        </Button>
+      </DialogActions>
+    </>
+  )
+}
+
+export default ODataActionsDialog
diff --git a/apps/sensenet/src/components/edit/default-content-type.ts b/apps/sensenet/src/components/edit/default-content-type.ts
index 289875716..d1b215428 100644
--- a/apps/sensenet/src/components/edit/default-content-type.ts
+++ b/apps/sensenet/src/components/edit/default-content-type.ts
@@ -14,6 +14,32 @@ type defaultSetting = {
   value: string
 }
 
+export const defaultContentTypeTemplates: defaultSetting[] = [
+  {
+    name: 'auiapplication',
+    title: 'AUIApplication CTD',
+    value: `<ContentType name="AUIApplication" parentType="Folder" handler="SenseNet.ContentRepository.Folder" xmlns="http://schemas.sensenet.com/SenseNet/ContentRepository/ContentTypeDefinition">
+  <DisplayName>Admin UI Application</DisplayName>
+  <Description>Custom Admin UI application that renders its HTML field instead of the folder grid.</Description>
+  <Icon>Content</Icon>
+  <AllowIncrementalNaming>true</AllowIncrementalNaming>
+  <Fields>
+    <Field name="Html" type="LongText">
+      <DisplayName>HTML</DisplayName>
+      <Description>HTML rendered by Admin UI when this content is opened. Referenced CSS and JavaScript files can be placed under this application folder and loaded with relative URLs.</Description>
+      <Configuration>
+        <TextType>LongText</TextType>
+        <ControlHint>sn:HtmlEditor</ControlHint>
+        <VisibleBrowse>Show</VisibleBrowse>
+        <VisibleEdit>Show</VisibleEdit>
+        <VisibleNew>Show</VisibleNew>
+      </Configuration>
+    </Field>
+  </Fields>
+</ContentType>`,
+  },
+]
+
 //CHANGE To comments
 export const defaultFieldSettings: defaultSetting[] = [
   {
diff --git a/apps/sensenet/src/components/editor/content-type-preset.tsx b/apps/sensenet/src/components/editor/content-type-preset.tsx
index 0d12c2609..55120b588 100644
--- a/apps/sensenet/src/components/editor/content-type-preset.tsx
+++ b/apps/sensenet/src/components/editor/content-type-preset.tsx
@@ -1,7 +1,7 @@
 import { Button } from '@material-ui/core'
 import React, { SetStateAction } from 'react'
 import { useLocalization } from '../../hooks'
-import { defaultFieldSettings } from '../edit/default-content-type'
+import { defaultContentTypeTemplates, defaultFieldSettings } from '../edit/default-content-type'
 
 export interface IAppProps {
   setTextValue: (value: SetStateAction<string>) => void
@@ -14,6 +14,25 @@ export const ContentTypePreset = (props: IAppProps) => {
 
   return (
     <>
+      <div className="title">{localization.textEditor.contentTypeTemplates}</div>
+      <div className="presets">
+        {defaultContentTypeTemplates.map((preset) => {
+          const { value, title, name } = preset
+
+          return (
+            <Button
+              key={title}
+              data-test={`preset-button-${name}`}
+              onClick={() => {
+                props.setTextValue(value)
+              }}
+              variant="outlined"
+              color="primary">
+              {title}
+            </Button>
+          )
+        })}
+      </div>
       <div className="title">{localization.textEditor.presets}</div>
       <div className="presets">
         {defaultFieldSettings.map((preset) => {
diff --git a/apps/sensenet/src/components/field-controls/form-properties-editor.tsx b/apps/sensenet/src/components/field-controls/form-properties-editor.tsx
new file mode 100644
index 000000000..397df8921
--- /dev/null
+++ b/apps/sensenet/src/components/field-controls/form-properties-editor.tsx
@@ -0,0 +1,613 @@
+import {
+  Button,
+  Checkbox,
+  createStyles,
+  Divider,
+  FormControlLabel,
+  Grid,
+  IconButton,
+  makeStyles,
+  MenuItem,
+  Paper,
+  Tab,
+  Tabs,
+  TextField,
+  Theme,
+  Typography,
+} from '@material-ui/core'
+import AddIcon from '@material-ui/icons/Add'
+import DeleteIcon from '@material-ui/icons/Delete'
+import { ReactClientFieldSetting } from '@sensenet/controls-react'
+import { LongTextFieldSetting } from '@sensenet/default-content-types'
+import React, { useEffect, useMemo, useState } from 'react'
+import { useLocalization } from '../../hooks'
+
+type FormFieldConfig = {
+  fieldName?: string
+  displayName?: string
+  placeholder?: string
+  required?: boolean
+  formatErrorMessage?: string
+  type?: string
+  minRows?: number
+  [key: string]: unknown
+}
+
+type PrivacyPolicyConfig = {
+  label?: string
+  tooltip?: string
+  modalCheckboxLabel?: string
+  acceptLabel?: string
+  declineLabel?: string
+  [key: string]: unknown
+}
+
+type FormPropertiesConfig = {
+  formTitle?: string
+  recaptcha?: boolean
+  formDesc?: string
+  submitBtn?: string
+  responseTitle?: string
+  responseMessage?: string
+  fieldErrorMessage?: string
+  requiredMessage?: string
+  requiredErrorMessage?: string
+  captchaErrorMessage?: string
+  errorMessage?: string
+  rows?: FormFieldConfig[][]
+  privacyPolicy?: PrivacyPolicyConfig
+  [key: string]: unknown
+}
+
+type FormPropertiesTextFieldKey =
+  | 'formTitle'
+  | 'formDesc'
+  | 'submitBtn'
+  | 'responseTitle'
+  | 'responseMessage'
+  | 'fieldErrorMessage'
+  | 'requiredMessage'
+  | 'requiredErrorMessage'
+  | 'captchaErrorMessage'
+  | 'errorMessage'
+
+type PrivacyPolicyFieldKey = 'label' | 'tooltip' | 'modalCheckboxLabel' | 'acceptLabel' | 'declineLabel'
+
+const defaultFormProperties: FormPropertiesConfig = {
+  recaptcha: false,
+  rows: [],
+  privacyPolicy: {},
+}
+
+const textFieldKeys: FormPropertiesTextFieldKey[] = [
+  'formTitle',
+  'formDesc',
+  'submitBtn',
+  'responseTitle',
+  'responseMessage',
+  'fieldErrorMessage',
+  'requiredMessage',
+  'requiredErrorMessage',
+  'captchaErrorMessage',
+  'errorMessage',
+]
+
+const privacyPolicyKeys: PrivacyPolicyFieldKey[] = [
+  'label',
+  'tooltip',
+  'modalCheckboxLabel',
+  'acceptLabel',
+  'declineLabel',
+]
+
+const formFieldTypeOptions = ['text', 'email', 'tel', 'textarea', 'number', 'checkbox', 'date', 'select']
+
+const useStyles = makeStyles((theme: Theme) =>
+  createStyles({
+    root: {
+      marginTop: theme.spacing(1),
+    },
+    section: {
+      borderRadius: 4,
+      marginTop: theme.spacing(2),
+      padding: theme.spacing(2),
+    },
+    sectionHeader: {
+      alignItems: 'center',
+      display: 'flex',
+      justifyContent: 'space-between',
+      marginBottom: theme.spacing(1),
+    },
+    fieldCard: {
+      border: `1px solid ${theme.palette.divider}`,
+      borderRadius: 4,
+      marginTop: theme.spacing(1),
+      padding: theme.spacing(2),
+    },
+    fieldHeader: {
+      alignItems: 'center',
+      display: 'flex',
+      justifyContent: 'space-between',
+      marginBottom: theme.spacing(1),
+    },
+    jsonEditor: {
+      fontFamily: 'monospace',
+    },
+    errorText: {
+      color: theme.palette.error.main,
+      marginTop: theme.spacing(1),
+    },
+    actions: {
+      display: 'flex',
+      gap: theme.spacing(1),
+      justifyContent: 'flex-end',
+      marginTop: theme.spacing(2),
+    },
+  }),
+)
+
+const formatLabel = (value: string) => {
+  return value
+    .replace(/([A-Z])/g, ' $1')
+    .replace(/^./, (firstLetter) => firstLetter.toUpperCase())
+    .trim()
+}
+
+const parseFormProperties = (rawValue: string): { value?: FormPropertiesConfig; error?: string } => {
+  if (!rawValue.trim()) {
+    return { value: { ...defaultFormProperties } }
+  }
+
+  try {
+    const parsedValue = JSON.parse(rawValue) as FormPropertiesConfig
+
+    return {
+      value: {
+        ...defaultFormProperties,
+        ...parsedValue,
+        rows: Array.isArray(parsedValue.rows) ? parsedValue.rows : [],
+        privacyPolicy: parsedValue.privacyPolicy || {},
+      },
+    }
+  } catch (error) {
+    return { error: error instanceof Error ? error.message : 'Invalid JSON' }
+  }
+}
+
+const stringifyFormProperties = (value: FormPropertiesConfig) => JSON.stringify(value, null, 2)
+
+export const FormPropertiesEditor: React.FC<ReactClientFieldSetting<LongTextFieldSetting>> = (props) => {
+  const classes = useStyles()
+  const localization = useLocalization().formPropertiesEditor
+  const initialRawValue = useMemo(
+    () => props.fieldValue || (props.actionName === 'new' && props.settings.DefaultValue) || '{}',
+    [props.actionName, props.fieldValue, props.settings.DefaultValue],
+  )
+  const initialParsedValue = useMemo(() => parseFormProperties(initialRawValue), [initialRawValue])
+  const [activeTab, setActiveTab] = useState<'visual' | 'json'>(initialParsedValue.error ? 'json' : 'visual')
+  const [rawValue, setRawValue] = useState(initialRawValue)
+  const [formProperties, setFormProperties] = useState<FormPropertiesConfig>(
+    initialParsedValue.value || { ...defaultFormProperties },
+  )
+  const [parseError, setParseError] = useState(initialParsedValue.error)
+  const isReadonly = Boolean(props.settings.ReadOnly)
+
+  useEffect(() => {
+    setRawValue(initialRawValue)
+    setParseError(initialParsedValue.error)
+
+    if (initialParsedValue.value) {
+      setFormProperties(initialParsedValue.value)
+    }
+
+    setActiveTab(initialParsedValue.error ? 'json' : 'visual')
+  }, [initialParsedValue.error, initialParsedValue.value, initialRawValue])
+
+  const emitFormProperties = (nextValue: FormPropertiesConfig) => {
+    const nextRawValue = stringifyFormProperties(nextValue)
+
+    setFormProperties(nextValue)
+    setRawValue(nextRawValue)
+    setParseError(undefined)
+    props.fieldOnChange?.(props.settings.Name, nextRawValue)
+  }
+
+  const updateRootField = (fieldName: FormPropertiesTextFieldKey | 'recaptcha', value: string | boolean) => {
+    emitFormProperties({
+      ...formProperties,
+      [fieldName]: value,
+    })
+  }
+
+  const updatePrivacyPolicyField = (fieldName: PrivacyPolicyFieldKey, value: string) => {
+    emitFormProperties({
+      ...formProperties,
+      privacyPolicy: {
+        ...(formProperties.privacyPolicy || {}),
+        [fieldName]: value,
+      },
+    })
+  }
+
+  const updateFormField = (rowIndex: number, fieldIndex: number, fieldPatch: Partial<FormFieldConfig>) => {
+    const rows = (formProperties.rows || []).map((row, currentRowIndex) =>
+      currentRowIndex === rowIndex
+        ? row.map((field, currentFieldIndex) =>
+            currentFieldIndex === fieldIndex ? { ...field, ...fieldPatch } : field,
+          )
+        : row,
+    )
+
+    emitFormProperties({
+      ...formProperties,
+      rows,
+    })
+  }
+
+  const updateFormFieldMinRows = (rowIndex: number, fieldIndex: number, value: string) => {
+    const nextMinRows = Number(value)
+    const rows = (formProperties.rows || []).map((row, currentRowIndex) =>
+      currentRowIndex === rowIndex
+        ? row.map((field, currentFieldIndex) => {
+            if (currentFieldIndex !== fieldIndex) {
+              return field
+            }
+
+            const nextField = { ...field }
+
+            if (value && Number.isFinite(nextMinRows)) {
+              nextField.minRows = nextMinRows
+            } else {
+              delete nextField.minRows
+            }
+
+            return nextField
+          })
+        : row,
+    )
+
+    emitFormProperties({
+      ...formProperties,
+      rows,
+    })
+  }
+
+  const addRow = () => {
+    emitFormProperties({
+      ...formProperties,
+      rows: [...(formProperties.rows || []), []],
+    })
+  }
+
+  const removeRow = (rowIndex: number) => {
+    emitFormProperties({
+      ...formProperties,
+      rows: (formProperties.rows || []).filter((_, currentRowIndex) => currentRowIndex !== rowIndex),
+    })
+  }
+
+  const addField = (rowIndex: number) => {
+    const rows = (formProperties.rows || []).map((row, currentRowIndex) =>
+      currentRowIndex === rowIndex
+        ? [
+            ...row,
+            {
+              fieldName: '',
+              displayName: '',
+              placeholder: '',
+              required: false,
+              type: 'text',
+            },
+          ]
+        : row,
+    )
+
+    emitFormProperties({
+      ...formProperties,
+      rows,
+    })
+  }
+
+  const removeField = (rowIndex: number, fieldIndex: number) => {
+    const rows = (formProperties.rows || []).map((row, currentRowIndex) =>
+      currentRowIndex === rowIndex ? row.filter((_, currentFieldIndex) => currentFieldIndex !== fieldIndex) : row,
+    )
+
+    emitFormProperties({
+      ...formProperties,
+      rows,
+    })
+  }
+
+  const handleRawValueChange = (event: React.ChangeEvent<HTMLInputElement>) => {
+    const nextRawValue = event.target.value
+    const parsedValue = parseFormProperties(nextRawValue)
+
+    setRawValue(nextRawValue)
+    setParseError(parsedValue.error)
+
+    if (parsedValue.value) {
+      setFormProperties(parsedValue.value)
+    }
+
+    props.fieldOnChange?.(props.settings.Name, nextRawValue)
+  }
+
+  const formatRawValue = () => {
+    const parsedValue = parseFormProperties(rawValue)
+
+    if (parsedValue.value) {
+      emitFormProperties(parsedValue.value)
+    } else {
+      setParseError(parsedValue.error)
+    }
+  }
+
+  const renderJsonEditor = () => (
+    <>
+      <TextField
+        className={classes.jsonEditor}
+        disabled={isReadonly}
+        fullWidth
+        multiline
+        name={props.settings.Name}
+        onChange={handleRawValueChange}
+        required={props.settings.Compulsory}
+        rows={18}
+        value={rawValue}
+        variant="outlined"
+      />
+      {parseError && (
+        <Typography className={classes.errorText} variant="body2">
+          {localization.invalidJson}: {parseError}
+        </Typography>
+      )}
+      <div className={classes.actions}>
+        <Button color="primary" disabled={isReadonly} onClick={formatRawValue} variant="outlined">
+          {localization.formatJson}
+        </Button>
+      </div>
+    </>
+  )
+
+  const renderVisualEditor = () => {
+    const rows = formProperties.rows || []
+
+    if (parseError) {
+      return (
+        <Typography className={classes.errorText} variant="body2">
+          {localization.fixJsonFirst}
+        </Typography>
+      )
+    }
+
+    return (
+      <>
+        <Paper className={classes.section} variant="outlined">
+          <Typography variant="subtitle1">{localization.generalSettings}</Typography>
+          <Grid container spacing={2}>
+            {textFieldKeys.map((fieldName) => (
+              <Grid item key={fieldName} md={6} xs={12}>
+                <TextField
+                  disabled={isReadonly}
+                  fullWidth
+                  label={formatLabel(fieldName)}
+                  onChange={(event) => updateRootField(fieldName, event.target.value)}
+                  value={(formProperties[fieldName] as string) || ''}
+                  variant="outlined"
+                />
+              </Grid>
+            ))}
+            <Grid item xs={12}>
+              <FormControlLabel
+                control={
+                  <Checkbox
+                    checked={Boolean(formProperties.recaptcha)}
+                    color="primary"
+                    disabled={isReadonly}
+                    onChange={(event) => updateRootField('recaptcha', event.target.checked)}
+                  />
+                }
+                label={localization.recaptcha}
+              />
+            </Grid>
+          </Grid>
+        </Paper>
+
+        <Paper className={classes.section} variant="outlined">
+          <div className={classes.sectionHeader}>
+            <Typography variant="subtitle1">{localization.rows}</Typography>
+            <Button color="primary" disabled={isReadonly} onClick={addRow} startIcon={<AddIcon />} variant="outlined">
+              {localization.addRow}
+            </Button>
+          </div>
+          {rows.map((row, rowIndex) => (
+            <Paper className={classes.fieldCard} key={rowIndex} variant="outlined">
+              <div className={classes.fieldHeader}>
+                <Typography variant="subtitle2">
+                  {localization.row} {rowIndex + 1}
+                </Typography>
+                <div>
+                  <Button
+                    color="primary"
+                    disabled={isReadonly}
+                    onClick={() => addField(rowIndex)}
+                    startIcon={<AddIcon />}
+                    size="small">
+                    {localization.addField}
+                  </Button>
+                  <IconButton disabled={isReadonly} onClick={() => removeRow(rowIndex)} size="small">
+                    <DeleteIcon />
+                  </IconButton>
+                </div>
+              </div>
+              {!row.length && (
+                <Typography color="textSecondary" variant="body2">
+                  {localization.emptyRow}
+                </Typography>
+              )}
+              {row.map((field, fieldIndex) => {
+                const typeOptions = formFieldTypeOptions.includes(field.type || '')
+                  ? formFieldTypeOptions
+                  : [field.type || 'text', ...formFieldTypeOptions]
+
+                return (
+                  <div className={classes.fieldCard} key={`${rowIndex}-${fieldIndex}`}>
+                    <div className={classes.fieldHeader}>
+                      <Typography variant="subtitle2">
+                        {field.fieldName || `${localization.field} ${fieldIndex + 1}`}
+                      </Typography>
+                      <IconButton disabled={isReadonly} onClick={() => removeField(rowIndex, fieldIndex)} size="small">
+                        <DeleteIcon />
+                      </IconButton>
+                    </div>
+                    <Grid container spacing={2}>
+                      <Grid item md={4} xs={12}>
+                        <TextField
+                          disabled={isReadonly}
+                          fullWidth
+                          label={localization.fieldName}
+                          onChange={(event) => updateFormField(rowIndex, fieldIndex, { fieldName: event.target.value })}
+                          value={field.fieldName || ''}
+                          variant="outlined"
+                        />
+                      </Grid>
+                      <Grid item md={4} xs={12}>
+                        <TextField
+                          disabled={isReadonly}
+                          fullWidth
+                          label={localization.displayName}
+                          onChange={(event) =>
+                            updateFormField(rowIndex, fieldIndex, { displayName: event.target.value })
+                          }
+                          value={field.displayName || ''}
+                          variant="outlined"
+                        />
+                      </Grid>
+                      <Grid item md={4} xs={12}>
+                        <TextField
+                          disabled={isReadonly}
+                          fullWidth
+                          label={localization.type}
+                          onChange={(event) => updateFormField(rowIndex, fieldIndex, { type: event.target.value })}
+                          select
+                          value={field.type || 'text'}
+                          variant="outlined">
+                          {typeOptions.map((typeOption) => (
+                            <MenuItem key={typeOption} value={typeOption}>
+                              {typeOption}
+                            </MenuItem>
+                          ))}
+                        </TextField>
+                      </Grid>
+                      <Grid item md={6} xs={12}>
+                        <TextField
+                          disabled={isReadonly}
+                          fullWidth
+                          label={localization.placeholder}
+                          onChange={(event) =>
+                            updateFormField(rowIndex, fieldIndex, { placeholder: event.target.value })
+                          }
+                          value={field.placeholder || ''}
+                          variant="outlined"
+                        />
+                      </Grid>
+                      <Grid item md={6} xs={12}>
+                        <TextField
+                          disabled={isReadonly}
+                          fullWidth
+                          label={localization.formatErrorMessage}
+                          onChange={(event) =>
+                            updateFormField(rowIndex, fieldIndex, { formatErrorMessage: event.target.value })
+                          }
+                          value={field.formatErrorMessage || ''}
+                          variant="outlined"
+                        />
+                      </Grid>
+                      <Grid item md={6} xs={12}>
+                        <FormControlLabel
+                          control={
+                            <Checkbox
+                              checked={Boolean(field.required)}
+                              color="primary"
+                              disabled={isReadonly}
+                              onChange={(event) =>
+                                updateFormField(rowIndex, fieldIndex, { required: event.target.checked })
+                              }
+                            />
+                          }
+                          label={localization.required}
+                        />
+                      </Grid>
+                      {field.type === 'textarea' && (
+                        <Grid item md={6} xs={12}>
+                          <TextField
+                            disabled={isReadonly}
+                            fullWidth
+                            label={localization.minRows}
+                            onChange={(event) => updateFormFieldMinRows(rowIndex, fieldIndex, event.target.value)}
+                            type="number"
+                            value={field.minRows ?? ''}
+                            variant="outlined"
+                          />
+                        </Grid>
+                      )}
+                    </Grid>
+                  </div>
+                )
+              })}
+            </Paper>
+          ))}
+        </Paper>
+
+        <Paper className={classes.section} variant="outlined">
+          <Typography variant="subtitle1">{localization.privacyPolicy}</Typography>
+          <Grid container spacing={2}>
+            {privacyPolicyKeys.map((fieldName) => (
+              <Grid item key={fieldName} md={6} xs={12}>
+                <TextField
+                  disabled={isReadonly}
+                  fullWidth
+                  label={formatLabel(fieldName)}
+                  onChange={(event) => updatePrivacyPolicyField(fieldName, event.target.value)}
+                  value={String((formProperties.privacyPolicy || {})[fieldName] || '')}
+                  variant="outlined"
+                />
+              </Grid>
+            ))}
+          </Grid>
+        </Paper>
+      </>
+    )
+  }
+
+  if (props.actionName === 'browse') {
+    return (
+      <div>
+        <Typography variant="caption" gutterBottom>
+          {`${props.settings.DisplayName} (${props.settings.Name})`}
+        </Typography>
+        <pre>{rawValue}</pre>
+      </div>
+    )
+  }
+
+  return (
+    <div className={classes.root}>
+      <Typography variant="caption" gutterBottom>
+        {`${props.settings.DisplayName} (${props.settings.Name})`}
+      </Typography>
+      {props.settings.Description && !props.hideDescription && (
+        <Typography color="textSecondary" variant="body2">
+          {props.settings.Description}
+        </Typography>
+      )}
+      <Tabs indicatorColor="primary" onChange={(_, value) => setActiveTab(value)} textColor="primary" value={activeTab}>
+        <Tab label={localization.visualEditor} value="visual" />
+        <Tab label={localization.jsonEditor} value="json" />
+      </Tabs>
+      <Divider />
+      {activeTab === 'visual' ? renderVisualEditor() : renderJsonEditor()}
+    </div>
+  )
+}
diff --git a/apps/sensenet/src/components/field-controls/index.ts b/apps/sensenet/src/components/field-controls/index.ts
index 3c7dbf03c..2f53f74c5 100644
--- a/apps/sensenet/src/components/field-controls/index.ts
+++ b/apps/sensenet/src/components/field-controls/index.ts
@@ -8,3 +8,4 @@ export * from './webhook-headers'
 export * from './webhook-payload'
 export * from './html-editor'
 export * from './tinymce-editor'
+export * from './form-properties-editor'
diff --git a/apps/sensenet/src/components/grid/Formatters/ActionFormatter.tsx b/apps/sensenet/src/components/grid/Formatters/ActionFormatter.tsx
index 70a2cad0b..c8839354e 100644
--- a/apps/sensenet/src/components/grid/Formatters/ActionFormatter.tsx
+++ b/apps/sensenet/src/components/grid/Formatters/ActionFormatter.tsx
@@ -5,7 +5,7 @@ import { ActionModel, GenericContent, isActionModel } from '@sensenet/default-co
 import { useLogger, useWopi } from '@sensenet/hooks-react'
 import React, { useCallback, useContext, useEffect, useState } from 'react'
 import { ResponsiveContext } from '../../../context'
-import { useLoadContent } from '../../../hooks'
+import { useLoadContent, useLocalization } from '../../../hooks'
 import { contextMenuODataOptions } from '../../context-menu/context-menu-odata-options'
 import { getIcon } from '../../context-menu/icons'
 import { useContextMenuActions } from '../../context-menu/use-context-menu-actions'
@@ -52,6 +52,7 @@ export function ActionFormatter(props: { data: Content }) {
 
   const { runAction } = useContextMenuActions(props.data, setActionsWopi)
   const device = useContext(ResponsiveContext)
+  const oDataActionsTitle = useLocalization().customActions.oDataActionsDialog.menuTitle
 
   useEffect(() => {
     if (content) {
@@ -65,12 +66,24 @@ export function ActionFormatter(props: { data: Content }) {
   const handleClose = () => {
     setAnchorEl(null)
   }
+  const runODataActions = () => {
+    setAnchorEl(null)
+    runAction('ODataActions')
+  }
   return (
     <>
       <IconButton aria-controls="simple-menu" className="simpleContextMenu" aria-haspopup="true" onClick={handleClick}>
         <MoreHoriz />
       </IconButton>
       <Menu id="simple-menu" anchorEl={anchorEl} keepMounted open={Boolean(anchorEl)} onClose={handleClose}>
+        <MenuItem
+          key="ODataActions"
+          disableRipple={true}
+          data-test="content-context-menu-odata-actions"
+          onClick={runODataActions}>
+          <ListItemIcon>{getIcon('odataactions')}</ListItemIcon>
+          <div style={{ flexGrow: 1 }}>{oDataActionsTitle}</div>
+        </MenuItem>
         {actions?.map((action) => {
           return (
             <MenuItem
diff --git a/apps/sensenet/src/components/grid/Grid.tsx b/apps/sensenet/src/components/grid/Grid.tsx
index 59afe822a..7f6d35f86 100644
--- a/apps/sensenet/src/components/grid/Grid.tsx
+++ b/apps/sensenet/src/components/grid/Grid.tsx
@@ -1,6 +1,6 @@
-import { debounce, LinearProgress, useTheme } from '@material-ui/core'
+import { CircularProgress, debounce, LinearProgress, Typography, useTheme } from '@material-ui/core'
 import { GenericContent } from '@sensenet/default-content-types'
-import { CurrentChildrenContext, CurrentContentContext } from '@sensenet/hooks-react'
+import { CurrentChildrenContext, CurrentChildrenIsLoadingContext, CurrentContentContext } from '@sensenet/hooks-react'
 import {
   CellContextMenuEvent,
   ColDef,
@@ -11,8 +11,8 @@ import {
   SelectionChangedEvent,
 } from 'ag-grid-community'
 import { AgGridReact } from 'ag-grid-react'
-import React, { useCallback, useContext, useEffect, useRef, useState } from 'react'
-import { useSelectionService } from '../../hooks'
+import React, { useCallback, useContext, useEffect, useMemo, useRef, useState } from 'react'
+import { useLocalization, useSelectionService } from '../../hooks'
 import { ContentContextMenu } from '../context-menu/content-context-menu'
 import { DropFileArea } from '../DropFileArea'
 import { GridProps } from './Props/GridProps'
@@ -23,16 +23,21 @@ const SMALL_SCREEN_COL_FILTER = ['Id', 'Actions']
 export function Grid<T extends GenericContent = GenericContent>(props: GridProps<T>) {
   const { isGridLoading, setIsGridLoading } = useGridLoading()
   const selectionService = useSelectionService()
+  const localization = useLocalization().common
   const parentContent = useContext(CurrentContentContext)
-  const children = (useContext(CurrentChildrenContext) as GenericContent[]).sort((a, b) => {
-    const aIsFolder = a.Type?.toLowerCase().includes('folder') ?? false
-    const bIsFolder = b.Type?.toLowerCase().includes('folder') ?? false
+  const currentChildren = useContext(CurrentChildrenContext) as GenericContent[]
+  const isCurrentChildrenLoading = useContext(CurrentChildrenIsLoadingContext)
+  const children = useMemo(() => {
+    return [...currentChildren].sort((a, b) => {
+      const aIsFolder = a.Type?.toLowerCase().includes('folder') ?? false
+      const bIsFolder = b.Type?.toLowerCase().includes('folder') ?? false
 
-    if (aIsFolder && !bIsFolder) return -1
-    if (!aIsFolder && bIsFolder) return 1
+      if (aIsFolder && !bIsFolder) return -1
+      if (!aIsFolder && bIsFolder) return 1
 
-    return (a.DisplayName ?? '').localeCompare(b.DisplayName ?? '')
-  })
+      return (a.DisplayName ?? '').localeCompare(b.DisplayName ?? '')
+    })
+  }, [currentChildren])
 
   const theme = useTheme()
   const [contextMenuItem, setContextMenuItem] = useState<GenericContent | null>(null)
@@ -203,9 +208,11 @@ export function Grid<T extends GenericContent = GenericContent>(props: GridProps
     }
   }, [props.gridKey])
 
+  const showGridLoading = isGridLoading || isCurrentChildrenLoading
+
   return (
-    <DropFileArea parentContent={parentContent} style={{ height: '100%', overflow: 'hidden' }}>
-      {isGridLoading && (
+    <DropFileArea parentContent={parentContent} style={{ height: '100%', overflow: 'hidden', position: 'relative' }}>
+      {showGridLoading && (
         <LinearProgress
           style={{
             position: 'absolute',
@@ -216,12 +223,13 @@ export function Grid<T extends GenericContent = GenericContent>(props: GridProps
           }}
         />
       )}
-      <div ref={gridRef} style={{ height: '100%', width: '100%' }}>
+      <div ref={gridRef} style={{ height: '100%', width: '100%' }} aria-busy={showGridLoading}>
         <AgGridReact
           rowData={children}
           columnDefs={columnDefs}
           className={theme.palette.type === 'light' ? 'ag-theme-balham' : 'ag-theme-balham-dark'}
           rowSelection={'multiple'}
+          suppressReactUi={true}
           tooltipShowDelay={100}
           onRowDoubleClicked={onRowDoubleClicked}
           preventDefaultOnContextMenu={true}
@@ -233,6 +241,34 @@ export function Grid<T extends GenericContent = GenericContent>(props: GridProps
           suppressNoRowsOverlay={true}
         />
       </div>
+      {showGridLoading && (
+        <div
+          style={{
+            position: 'absolute',
+            top: 0,
+            right: 0,
+            bottom: 0,
+            left: 0,
+            zIndex: 9,
+            display: 'flex',
+            alignItems: 'center',
+            justifyContent: 'center',
+            pointerEvents: 'none',
+            backgroundColor: theme.palette.type === 'light' ? 'rgba(255, 255, 255, 0.55)' : 'rgba(18, 18, 18, 0.35)',
+          }}>
+          <div
+            style={{
+              display: 'flex',
+              flexDirection: 'column',
+              alignItems: 'center',
+              gap: 12,
+              color: theme.palette.text.primary,
+            }}>
+            <CircularProgress size={34} />
+            <Typography variant="body2">{localization.loadingContent}</Typography>
+          </div>
+        </div>
+      )}
       {contextMenuItem && (
         <ContentContextMenu
           isOpened={isContextMenuOpened}
diff --git a/apps/sensenet/src/components/grid/Providers/GridLoadingProvider.tsx b/apps/sensenet/src/components/grid/Providers/GridLoadingProvider.tsx
index 813a08c44..a777e055e 100644
--- a/apps/sensenet/src/components/grid/Providers/GridLoadingProvider.tsx
+++ b/apps/sensenet/src/components/grid/Providers/GridLoadingProvider.tsx
@@ -12,7 +12,7 @@ interface GridLoadingProviderProps {
 }
 
 export const GridLoadingProvider: React.FC<GridLoadingProviderProps> = ({ children }) => {
-  const [isGridLoading, setIsGridLoading] = useState<boolean>(true)
+  const [isGridLoading, setIsGridLoading] = useState<boolean>(false)
 
   return (
     <GridLoadingContext.Provider value={{ isGridLoading, setIsGridLoading }}>{children}</GridLoadingContext.Provider>
diff --git a/apps/sensenet/src/components/home-activity-summary.tsx b/apps/sensenet/src/components/home-activity-summary.tsx
new file mode 100644
index 000000000..315f9607b
--- /dev/null
+++ b/apps/sensenet/src/components/home-activity-summary.tsx
@@ -0,0 +1,531 @@
+import { createStyles, makeStyles, Theme, Typography } from '@material-ui/core'
+import { AssessmentOutlined, DescriptionOutlined, GroupOutlined, Update } from '@material-ui/icons'
+import React, { useMemo } from 'react'
+import type { AuthContextModel } from '../context/auth-provider'
+import { useLocalization } from '../hooks'
+import { UserAvatar } from './UserAvatar'
+
+interface HomeActivitySummaryProps {
+  logs: HomeActivityLog[]
+  repositoryUrl: string
+  user?: AuthContextModel['user']
+}
+
+interface HomeActivityLog {
+  ContentId?: number | string
+  ContentPath?: string
+  LogDate?: string
+  Message?: string
+  UserName?: string
+}
+
+interface ChartItem {
+  label: string
+  value: number
+}
+
+interface UserDetail {
+  label: string
+  value?: string | number | null
+}
+
+interface LoginItem {
+  count: number
+  lastLogin?: string
+  userName: string
+}
+
+type HomeLocalization = ReturnType<typeof useLocalization>['home']
+
+type UserWithDomain = {
+  Domain?: string
+}
+
+const useStyles = makeStyles((theme: Theme) =>
+  createStyles({
+    root: {
+      marginBottom: '28px',
+    },
+    header: {
+      display: 'flex',
+      justifyContent: 'space-between',
+      alignItems: 'baseline',
+      gap: '16px',
+      marginBottom: '16px',
+      [theme.breakpoints.down(600)]: {
+        flexDirection: 'column',
+        gap: '4px',
+      },
+    },
+    title: {
+      fontSize: '24px',
+      fontWeight: 500,
+      color: theme.palette.type === 'light' ? '#333' : '#fff',
+      margin: 0,
+    },
+    caption: {
+      color: theme.palette.text.secondary,
+      whiteSpace: 'nowrap',
+    },
+    userPanel: {
+      display: 'grid',
+      gridTemplateColumns: 'auto 1fr',
+      gap: '18px',
+      alignItems: 'center',
+      padding: '20px',
+      marginBottom: '16px',
+      borderRadius: '8px',
+      border: `1px solid ${theme.palette.type === 'light' ? '#e2e8f0' : '#454545'}`,
+      backgroundColor: theme.palette.type === 'light' ? '#fff' : '#303030',
+      [theme.breakpoints.down(600)]: {
+        gridTemplateColumns: '1fr',
+      },
+    },
+    avatar: {
+      width: '64px',
+      height: '64px',
+      fontSize: '28px',
+      backgroundColor: theme.palette.primary.main,
+      color: theme.palette.primary.contrastText,
+    },
+    userName: {
+      fontSize: '26px',
+      lineHeight: 1.2,
+      fontWeight: 600,
+      color: theme.palette.type === 'light' ? '#1f2937' : '#fff',
+      marginBottom: '10px',
+    },
+    userDetails: {
+      display: 'grid',
+      gridTemplateColumns: 'repeat(4, minmax(0, 1fr))',
+      gap: '12px',
+      [theme.breakpoints.down(1200)]: {
+        gridTemplateColumns: 'repeat(2, minmax(0, 1fr))',
+      },
+      [theme.breakpoints.down(600)]: {
+        gridTemplateColumns: '1fr',
+      },
+    },
+    userDetailLabel: {
+      color: theme.palette.text.secondary,
+      fontSize: '12px',
+      textTransform: 'uppercase',
+      marginBottom: '2px',
+    },
+    userDetailValue: {
+      color: theme.palette.type === 'light' ? '#374151' : '#f5f5f5',
+      overflow: 'hidden',
+      textOverflow: 'ellipsis',
+      whiteSpace: 'nowrap',
+    },
+    metricGrid: {
+      display: 'grid',
+      gridTemplateColumns: 'repeat(4, minmax(0, 1fr))',
+      gap: '16px',
+      marginBottom: '16px',
+      [theme.breakpoints.down(960)]: {
+        gridTemplateColumns: 'repeat(2, minmax(0, 1fr))',
+      },
+      [theme.breakpoints.down(600)]: {
+        gridTemplateColumns: '1fr',
+      },
+    },
+    metricCard: {
+      minHeight: '112px',
+      padding: '18px',
+      borderRadius: '8px',
+      border: `1px solid ${theme.palette.type === 'light' ? '#e2e8f0' : '#454545'}`,
+      backgroundColor: theme.palette.type === 'light' ? '#f8fafc' : '#343434',
+      display: 'flex',
+      flexDirection: 'column',
+      justifyContent: 'space-between',
+    },
+    metricHeader: {
+      display: 'flex',
+      justifyContent: 'space-between',
+      alignItems: 'center',
+      gap: '12px',
+    },
+    metricLabel: {
+      color: theme.palette.text.secondary,
+      fontSize: '14px',
+      overflow: 'hidden',
+      textOverflow: 'ellipsis',
+      whiteSpace: 'nowrap',
+    },
+    metricIcon: {
+      color: theme.palette.primary.main,
+      flexShrink: 0,
+    },
+    metricValue: {
+      fontSize: '34px',
+      lineHeight: 1,
+      fontWeight: 600,
+      color: theme.palette.type === 'light' ? '#1f2937' : '#fff',
+      marginTop: '16px',
+    },
+    chartGrid: {
+      display: 'grid',
+      gridTemplateColumns: 'repeat(3, minmax(0, 1fr))',
+      gap: '16px',
+      [theme.breakpoints.down(1200)]: {
+        gridTemplateColumns: 'repeat(2, minmax(0, 1fr))',
+      },
+      [theme.breakpoints.down(800)]: {
+        gridTemplateColumns: '1fr',
+      },
+    },
+    chartCard: {
+      padding: '18px',
+      borderRadius: '8px',
+      border: `1px solid ${theme.palette.type === 'light' ? '#e2e8f0' : '#454545'}`,
+      backgroundColor: theme.palette.type === 'light' ? '#fff' : '#303030',
+      minHeight: '220px',
+    },
+    chartTitle: {
+      fontSize: '16px',
+      fontWeight: 600,
+      marginBottom: '16px',
+      color: theme.palette.type === 'light' ? '#333' : '#fff',
+    },
+    barRow: {
+      display: 'grid',
+      gridTemplateColumns: 'minmax(96px, 160px) 1fr 44px',
+      gap: '12px',
+      alignItems: 'center',
+      marginBottom: '12px',
+      [theme.breakpoints.down(600)]: {
+        gridTemplateColumns: '1fr 44px',
+      },
+    },
+    barLabel: {
+      color: theme.palette.text.secondary,
+      overflow: 'hidden',
+      textOverflow: 'ellipsis',
+      whiteSpace: 'nowrap',
+      [theme.breakpoints.down(600)]: {
+        gridColumn: '1 / 2',
+      },
+    },
+    barTrack: {
+      height: '10px',
+      borderRadius: '999px',
+      overflow: 'hidden',
+      backgroundColor: theme.palette.type === 'light' ? '#e5e7eb' : '#505050',
+      [theme.breakpoints.down(600)]: {
+        gridColumn: '1 / 2',
+      },
+    },
+    barFill: {
+      height: '100%',
+      minWidth: '6px',
+      borderRadius: '999px',
+      backgroundColor: theme.palette.primary.main,
+    },
+    barValue: {
+      textAlign: 'right',
+      fontWeight: 600,
+      color: theme.palette.type === 'light' ? '#374151' : '#f5f5f5',
+      [theme.breakpoints.down(600)]: {
+        gridColumn: '2 / 3',
+        gridRow: '1 / 3',
+      },
+    },
+    emptyState: {
+      minHeight: '150px',
+      display: 'flex',
+      alignItems: 'center',
+      color: theme.palette.text.secondary,
+    },
+    loginList: {
+      display: 'flex',
+      flexDirection: 'column',
+      gap: '12px',
+    },
+    loginRow: {
+      display: 'grid',
+      gridTemplateColumns: '1fr auto',
+      gap: '12px',
+      alignItems: 'center',
+      paddingBottom: '12px',
+      borderBottom: `1px solid ${theme.palette.type === 'light' ? '#e5e7eb' : '#454545'}`,
+      '&:last-child': {
+        borderBottom: 0,
+        paddingBottom: 0,
+      },
+    },
+    loginUser: {
+      color: theme.palette.type === 'light' ? '#374151' : '#f5f5f5',
+      fontWeight: 600,
+      overflow: 'hidden',
+      textOverflow: 'ellipsis',
+      whiteSpace: 'nowrap',
+    },
+    loginMeta: {
+      color: theme.palette.text.secondary,
+      fontSize: '13px',
+    },
+    loginCount: {
+      color: theme.palette.text.secondary,
+      whiteSpace: 'nowrap',
+    },
+  }),
+)
+
+const formatMessage = (message?: string) => (message || '').replace(/([a-z])([A-Z])/g, '$1 $2')
+
+const normalizeLabel = (value?: string) => (value || '').trim().toLocaleLowerCase()
+
+const isContentUpdate = (log: HomeActivityLog) => normalizeLabel(formatMessage(log.Message)) === 'content updated'
+
+const isLoginSuccessful = (log: HomeActivityLog) => normalizeLabel(formatMessage(log.Message)) === 'login successful'
+
+const formatLogDate = (value?: string) => {
+  if (!value) return ''
+
+  const date = new Date(value)
+  if (Number.isNaN(date.getTime())) return ''
+
+  const year = date.getFullYear()
+  const month = String(date.getMonth() + 1).padStart(2, '0')
+  const day = String(date.getDate()).padStart(2, '0')
+  const hours = String(date.getHours()).padStart(2, '0')
+  const minutes = String(date.getMinutes()).padStart(2, '0')
+
+  return `${year}-${month}-${day} ${hours}:${minutes}`
+}
+
+const getUserDisplayName = (user?: AuthContextModel['user']) => {
+  return user?.FullName || user?.DisplayName || user?.Name || user?.LoginName || 'User'
+}
+
+const getUserDomain = (user?: AuthContextModel['user']) => {
+  return user && 'Domain' in user ? (user as UserWithDomain).Domain : undefined
+}
+
+const getUserDetails = (user: AuthContextModel['user'], localization: HomeLocalization) => {
+  const details: UserDetail[] = [
+    { label: localization.userLoginName, value: user?.LoginName || user?.Name },
+    { label: localization.userEmail, value: user?.Email },
+    { label: localization.userPath, value: user?.Path },
+    { label: localization.userDomain, value: getUserDomain(user) },
+  ]
+
+  return details.filter((detail) => detail.value)
+}
+
+const getTopItems = (items: (string | undefined)[], limit = 5): ChartItem[] => {
+  const counts = items.reduce<Record<string, ChartItem>>((acc, item) => {
+    const key = normalizeLabel(item)
+    if (!key) return acc
+
+    if (!acc[key]) {
+      acc[key] = { label: item?.trim() || '', value: 0 }
+    }
+    acc[key].value += 1
+    return acc
+  }, {})
+
+  return Object.values(counts)
+    .sort((a, b) => b.value - a.value)
+    .slice(0, limit)
+}
+
+const getRecentLogins = (logs: HomeActivityLog[], limit = 6): LoginItem[] => {
+  const logins = logs.filter(isLoginSuccessful)
+  const grouped = logins.reduce<Record<string, LoginItem>>((acc, log) => {
+    const key = normalizeLabel(log.UserName)
+    if (!key) return acc
+
+    if (!acc[key]) {
+      acc[key] = {
+        count: 0,
+        lastLogin: log.LogDate,
+        userName: log.UserName || '',
+      }
+    }
+
+    acc[key].count += 1
+    const currentLastLogin = acc[key].lastLogin ? new Date(acc[key].lastLogin).getTime() : 0
+    const nextLogin = log.LogDate ? new Date(log.LogDate).getTime() : 0
+    if (nextLogin > currentLastLogin) {
+      acc[key].lastLogin = log.LogDate
+      acc[key].userName = log.UserName || acc[key].userName
+    }
+
+    return acc
+  }, {})
+
+  return Object.values(grouped)
+    .sort((a, b) => new Date(b.lastLogin || '').getTime() - new Date(a.lastLogin || '').getTime())
+    .slice(0, limit)
+}
+
+const BarChart = ({ items, emptyText }: { items: ChartItem[]; emptyText: string }) => {
+  const classes = useStyles()
+  const maxValue = Math.max(...items.map((item) => item.value), 1)
+
+  if (!items.length) {
+    return <div className={classes.emptyState}>{emptyText}</div>
+  }
+
+  return (
+    <>
+      {items.map((item) => (
+        <div className={classes.barRow} key={item.label}>
+          <Typography className={classes.barLabel} title={item.label}>
+            {item.label}
+          </Typography>
+          <div className={classes.barTrack}>
+            <div className={classes.barFill} style={{ width: `${(item.value / maxValue) * 100}%` }} />
+          </div>
+          <Typography className={classes.barValue}>{item.value}</Typography>
+        </div>
+      ))}
+    </>
+  )
+}
+
+const LoginList = ({ items, localization }: { items: LoginItem[]; localization: HomeLocalization }) => {
+  const classes = useStyles()
+
+  if (!items.length) {
+    return <div className={classes.emptyState}>{localization.activityNoLogins}</div>
+  }
+
+  return (
+    <div className={classes.loginList}>
+      {items.map((item) => (
+        <div className={classes.loginRow} key={normalizeLabel(item.userName)}>
+          <div>
+            <Typography className={classes.loginUser} title={item.userName}>
+              {item.userName}
+            </Typography>
+            <div className={classes.loginMeta}>
+              {localization.activityLastLogin}: {formatLogDate(item.lastLogin)}
+            </div>
+          </div>
+          <div className={classes.loginCount}>{localization.activityLoginCount(item.count)}</div>
+        </div>
+      ))}
+    </div>
+  )
+}
+
+export const HomeActivitySummary: React.FunctionComponent<HomeActivitySummaryProps> = ({
+  logs,
+  repositoryUrl,
+  user,
+}) => {
+  const classes = useStyles()
+  const localization = useLocalization().home
+  const numberFormatter = new Intl.NumberFormat('en-US')
+  const userDisplayName = getUserDisplayName(user)
+  const userDetails = getUserDetails(user, localization)
+
+  const summary = useMemo(() => {
+    const contentIds = new Set<string>()
+    const users = new Set<string>()
+
+    logs.forEach((log) => {
+      if (log.ContentId || log.ContentPath) {
+        contentIds.add(String(log.ContentId || log.ContentPath).toLocaleLowerCase())
+      }
+      if (log.UserName) users.add(normalizeLabel(log.UserName))
+    })
+
+    const contentUpdateLogs = logs.filter(isContentUpdate)
+    const operations = getTopItems(logs.map((log) => formatMessage(log.Message)))
+    const recentLogins = getRecentLogins(logs)
+
+    return {
+      total: logs.length,
+      activeUsers: users.size,
+      touchedContent: contentIds.size,
+      contentUpdates: contentUpdateLogs.length,
+      operations,
+      editors: getTopItems(contentUpdateLogs.map((log) => log.UserName)),
+      recentLogins,
+    }
+  }, [logs])
+
+  const metrics = [
+    {
+      label: localization.activityLogEntries,
+      value: summary.total,
+      icon: <AssessmentOutlined className={classes.metricIcon} />,
+    },
+    {
+      label: localization.activityUsers,
+      value: summary.activeUsers,
+      icon: <GroupOutlined className={classes.metricIcon} />,
+    },
+    {
+      label: localization.activityContent,
+      value: summary.touchedContent,
+      icon: <DescriptionOutlined className={classes.metricIcon} />,
+    },
+    {
+      label: localization.activityUpdates,
+      value: summary.contentUpdates,
+      icon: <Update className={classes.metricIcon} />,
+    },
+  ]
+
+  return (
+    <section className={classes.root}>
+      <div className={classes.header}>
+        <Typography variant="h2" component="div" className={classes.title}>
+          {localization.activityOverview}
+        </Typography>
+        <Typography className={classes.caption}>{localization.activityWindow}</Typography>
+      </div>
+      <div className={classes.userPanel}>
+        <UserAvatar
+          user={user}
+          repositoryUrl={repositoryUrl}
+          avatarProps={{ className: classes.avatar }}
+          style={{ width: 64, height: 64, fontSize: 28 }}
+        />
+        <div>
+          <div className={classes.userName}>{localization.userGreeting(userDisplayName)}</div>
+          <div className={classes.userDetails}>
+            {userDetails.map((detail) => (
+              <div key={detail.label}>
+                <div className={classes.userDetailLabel}>{detail.label}</div>
+                <Typography className={classes.userDetailValue} title={String(detail.value)}>
+                  {detail.value}
+                </Typography>
+              </div>
+            ))}
+          </div>
+        </div>
+      </div>
+      <div className={classes.metricGrid}>
+        {metrics.map((metric) => (
+          <div className={classes.metricCard} key={metric.label}>
+            <div className={classes.metricHeader}>
+              <Typography className={classes.metricLabel}>{metric.label}</Typography>
+              {metric.icon}
+            </div>
+            <div className={classes.metricValue}>{numberFormatter.format(metric.value)}</div>
+          </div>
+        ))}
+      </div>
+      <div className={classes.chartGrid}>
+        <div className={classes.chartCard}>
+          <div className={classes.chartTitle}>{localization.activityOperations}</div>
+          <BarChart items={summary.operations} emptyText={localization.activityNoData} />
+        </div>
+        <div className={classes.chartCard}>
+          <div className={classes.chartTitle}>{localization.activityEditors}</div>
+          <BarChart items={summary.editors} emptyText={localization.activityNoData} />
+        </div>
+        <div className={classes.chartCard}>
+          <div className={classes.chartTitle}>{localization.activityLogins}</div>
+          <LoginList items={summary.recentLogins} localization={localization} />
+        </div>
+      </div>
+    </section>
+  )
+}
diff --git a/apps/sensenet/src/components/react-control-mapper.ts b/apps/sensenet/src/components/react-control-mapper.ts
index f835ba408..abfb02d89 100644
--- a/apps/sensenet/src/components/react-control-mapper.ts
+++ b/apps/sensenet/src/components/react-control-mapper.ts
@@ -30,7 +30,13 @@ export const reactControlMapper = (repository: Repository) => {
       }
     })
     .setupFieldSettingDefault<LongTextFieldSetting>('LongTextFieldSetting', (setting) => {
+      if (setting.Name === 'FormPropertiesJSON') {
+        return FieldControls.FormPropertiesEditor
+      }
+
       switch (setting.ControlHint) {
+        case 'sn:FormPropertiesEditor':
+          return FieldControls.FormPropertiesEditor
         case 'sn:WebhookFilter':
           return FieldControls.WebhookTrigger
         case 'sn:WebhookHeaders':
diff --git a/apps/sensenet/src/components/tree/Contexts/ExpandedItemsProvider.tsx b/apps/sensenet/src/components/tree/Contexts/ExpandedItemsProvider.tsx
index 42c61d38d..c93653ce1 100644
--- a/apps/sensenet/src/components/tree/Contexts/ExpandedItemsProvider.tsx
+++ b/apps/sensenet/src/components/tree/Contexts/ExpandedItemsProvider.tsx
@@ -54,6 +54,7 @@ const ExpandedItemsProvider = ({ children }: { children: ReactNode }) => {
         path,
         oDataOptions: {
           select: ['Id', 'Path', 'Name', 'DisplayName', 'Type', 'Actions', 'Icon', 'ParentId'],
+          filter: 'IsFolder eq true',
           onlyselectList: true,
         },
       })
diff --git a/apps/sensenet/src/localization/default.ts b/apps/sensenet/src/localization/default.ts
index 7d5b665f4..3f72bee89 100644
--- a/apps/sensenet/src/localization/default.ts
+++ b/apps/sensenet/src/localization/default.ts
@@ -21,6 +21,7 @@ const values = {
   commandPalette: {
     title: 'Search',
     clear: 'Clear',
+    actions: 'Actions',
     help: {
       readMeTitle: 'ReadMe',
       readMeDescription: 'Opens the latest readme.md file from GitHub in a new window',
@@ -298,6 +299,7 @@ const values = {
     saveSuccessNotification: `The changes of '{0}' has been saved`,
     saveFailedNotification: `Failed to save changes of content '{0}'`,
     presets: 'Presets',
+    contentTypeTemplates: 'Content type templates',
     hints: {
       newContentTypeEditHint: `Please edit the <b>name</b>, <b>parent type</b> and <b>handler</b> attributes before saving!`,
       contentTypeTutorialrefenceHint: `Further <a href="https://docs.sensenet.com/tutorials/content-types" target="_blank" rel="noopener noreferrer"> informations </a>`,
@@ -501,6 +503,19 @@ const values = {
     unavailableRegenSecret: 'Currently regenerate secret is unavailable',
   },
   customActions: {
+    oDataActionsDialog: {
+      menuTitle: 'OData Actions',
+      title: `OData Actions for '{0}'`,
+      actionLabel: 'Action',
+      loadingActions: 'Loading OData actions...',
+      noActions: 'There are no OData actions available for this content.',
+      loadError: 'Failed to load OData actions.',
+      parameters: 'Parameters',
+      noParameters: 'The selected action does not have any parameters.',
+      cancelButton: 'Cancel',
+      executeButton: 'Execute',
+      executingAction: 'Executing OData action...',
+    },
     executeCustomActionDialog: {
       title: `Execute custom action '{0}' on content '{1}'`,
       noParameters: 'The action does not have any parameters',
@@ -553,11 +568,53 @@ const values = {
   common: {
     loadingContent: 'Loading content...',
   },
+  formPropertiesEditor: {
+    visualEditor: 'Visual editor',
+    jsonEditor: 'JSON',
+    generalSettings: 'General settings',
+    rows: 'Rows',
+    row: 'Row',
+    field: 'Field',
+    addRow: 'Add row',
+    addField: 'Add field',
+    emptyRow: 'This row has no fields yet.',
+    fieldName: 'Field name',
+    displayName: 'Display name',
+    placeholder: 'Placeholder',
+    type: 'Type',
+    required: 'Required',
+    formatErrorMessage: 'Format error message',
+    minRows: 'Minimum rows',
+    recaptcha: 'Use recaptcha',
+    privacyPolicy: 'Privacy policy',
+    invalidJson: 'Invalid JSON',
+    fixJsonFirst: 'The visual editor is available after the JSON is valid.',
+    formatJson: 'Format JSON',
+  },
   batchActions: {
     delete: 'Delete selected items',
     move: 'Move selected items',
     copy: 'Copy selected items',
     copyPath: 'Copy path',
+    downloadZip: 'Download selected items as ZIP',
+    downloadZipSuccess: '{0} files and {1} folders downloaded as ZIP',
+    downloadZipError: 'There was an error during ZIP download',
+    exportCsv: 'Export selected items to CSV',
+    exportCsvSuccess: '{0} items exported to CSV',
+    exportCsvError: 'There was an error during CSV export',
+    exportCsvDialogTitle: 'Export CSV',
+    exportCsvSelectionSummary: '{0} selected items from {1} content types',
+    exportCsvContentType: 'Content type',
+    exportCsvSearchFields: 'Search fields',
+    exportCsvSelectAllTypeFields: 'Select all',
+    exportCsvClearTypeFields: 'Clear',
+    exportCsvNoFields: 'No fields available',
+    exportCsvSelectedFields: 'Selected fields',
+    exportCsvSelectedFieldCount: '{0} fields selected',
+    exportCsvClearSelectedFields: 'Clear all',
+    exportCsvNoSelectedFields: 'Select at least one field to export',
+    exportCsvExportButton: 'Download',
+    exportCsvExporting: 'Preparing...',
   },
   referenceContentListDialog: {
     errorAlreadyInList: 'The selected item is already in the list',
@@ -692,6 +749,24 @@ const values = {
     success: 'Succesfull Operation',
   },
   home: {
+    activityOverview: 'Activity overview',
+    activityWindow: 'Last 10 hours',
+    activityLogEntries: 'Log entries',
+    activityUsers: 'Active users',
+    activityContent: 'Touched content',
+    activityUpdates: 'Content updates',
+    activityOperations: 'Operations in the last 10 hours',
+    activityEditors: 'Active editors in the last 10 hours',
+    activityLogins: 'Recent logins in the last 10 hours',
+    activityNoData: 'No activity data in this period.',
+    activityNoLogins: 'No successful logins in this period.',
+    activityLastLogin: 'Last login',
+    activityLoginCount: (count: number) => `${count} ${count === 1 ? 'login' : 'logins'}`,
+    userGreeting: (name: string) => `Hello ${name}`,
+    userLoginName: 'Login name',
+    userEmail: 'Email',
+    userPath: 'Path',
+    userDomain: 'Domain',
     latestChanges: 'Latest Changes',
     oldValue: 'Old Value',
     newValue: 'New Value',
diff --git a/apps/sensenet/src/localization/hungarian.ts b/apps/sensenet/src/localization/hungarian.ts
index 1d839aab4..0a4954e1f 100644
--- a/apps/sensenet/src/localization/hungarian.ts
+++ b/apps/sensenet/src/localization/hungarian.ts
@@ -11,6 +11,7 @@ const values: Localization = {
   },
   commandPalette: {
     title: 'Command palette megnyitása',
+    actions: 'Műveletek',
     searchSuggestionList: 'Keresési javaslatok listája',
   },
   contentInfoDialog: {
@@ -222,10 +223,52 @@ const values: Localization = {
   common: {
     loadingContent: 'Tartalom betöltése...',
   },
+  formPropertiesEditor: {
+    visualEditor: 'Grafikus szerkesztő',
+    jsonEditor: 'JSON',
+    generalSettings: 'Általános beállítások',
+    rows: 'Sorok',
+    row: 'Sor',
+    field: 'Mező',
+    addRow: 'Sor hozzáadása',
+    addField: 'Mező hozzáadása',
+    emptyRow: 'Ebben a sorban még nincs mező.',
+    fieldName: 'Mező neve',
+    displayName: 'Megjelenített név',
+    placeholder: 'Placeholder',
+    type: 'Típus',
+    required: 'Kötelező',
+    formatErrorMessage: 'Formátumhiba üzenet',
+    minRows: 'Minimum sorok',
+    recaptcha: 'Recaptcha használata',
+    privacyPolicy: 'Adatvédelmi nyilatkozat',
+    invalidJson: 'Érvénytelen JSON',
+    fixJsonFirst: 'A grafikus szerkesztő akkor használható, ha a JSON érvényes.',
+    formatJson: 'JSON formázása',
+  },
   batchActions: {
     delete: 'Kijelölt elemek törlése',
     move: 'Kijelölt elemek áthelyezése',
     copy: 'Kijelölt elemek másolása',
+    downloadZip: 'Kijelölt elemek letöltése ZIP-ben',
+    downloadZipSuccess: '{0} fájl és {1} mappa letöltve ZIP-ben',
+    downloadZipError: 'Hiba történt a ZIP letöltés során',
+    exportCsv: 'Kijelölt elemek exportálása CSV-be',
+    exportCsvSuccess: '{0} elem exportálva CSV-be',
+    exportCsvError: 'Hiba történt a CSV exportálás során',
+    exportCsvDialogTitle: 'CSV export',
+    exportCsvSelectionSummary: '{0} kijelölt elem, {1} tartalomtípus alapján',
+    exportCsvContentType: 'Tartalomtípus',
+    exportCsvSearchFields: 'Mezők keresése',
+    exportCsvSelectAllTypeFields: 'Összes kijelölése',
+    exportCsvClearTypeFields: 'Törlés',
+    exportCsvNoFields: 'Nincs elérhető mező',
+    exportCsvSelectedFields: 'Kijelölt mezők',
+    exportCsvSelectedFieldCount: '{0} mező kijelölve',
+    exportCsvClearSelectedFields: 'Összes törlése',
+    exportCsvNoSelectedFields: 'Válassz legalább egy mezőt az exporthoz',
+    exportCsvExportButton: 'Letöltés',
+    exportCsvExporting: 'Előkészítés...',
   },
   permissionEditor: {
     assign: 'Új jogosultság hozzáadása',
@@ -382,6 +425,30 @@ const values: Localization = {
     userGroups: (userName: string) => `${userName} csoportjai`,
     userNoMembership: (userName: string) => `${userName} nem tagja egyetlen csoportnak sem`,
   },
+  home: {
+    activityOverview: 'Aktivitási áttekintés',
+    activityWindow: 'Az elmúlt 10 óra',
+    activityLogEntries: 'Naplóbejegyzések',
+    activityUsers: 'Aktív felhasználók',
+    activityContent: 'Érintett tartalmak',
+    activityUpdates: 'Tartalommódosítások',
+    activityOperations: 'Műveletek az elmúlt 10 órában',
+    activityEditors: 'Aktív szerkesztők az elmúlt 10 órában',
+    activityLogins: 'Belépések az elmúlt 10 órában',
+    activityNoData: 'Ebben az időszakban nincs aktivitási adat.',
+    activityNoLogins: 'Ebben az időszakban nem volt sikeres belépés.',
+    activityLastLogin: 'Utolsó belépés',
+    activityLoginCount: (count: number) => `${count} belépés`,
+    userGreeting: (name: string) => `Hello ${name}`,
+    userLoginName: 'Bejelentkezési név',
+    userEmail: 'Email',
+    userPath: 'Elérési út',
+    userDomain: 'Domain',
+    latestChanges: 'Legutóbbi változások',
+    oldValue: 'Régi érték',
+    newValue: 'Új érték',
+    contentHistory: 'Tartalom előzmények',
+  },
 }
 
 export default values
diff --git a/apps/sensenet/src/services/CommandProviders/CustomActionCommandProvider.ts b/apps/sensenet/src/services/CommandProviders/CustomActionCommandProvider.ts
index 6f6e4d24d..2dd002e67 100644
--- a/apps/sensenet/src/services/CommandProviders/CustomActionCommandProvider.ts
+++ b/apps/sensenet/src/services/CommandProviders/CustomActionCommandProvider.ts
@@ -1,10 +1,17 @@
-import { MetadataAction, ODataResponse, Repository } from '@sensenet/client-core'
+import type { MetadataAction, ODataResponse, Repository } from '@sensenet/client-core'
 import { Injectable, ObservableValue } from '@sensenet/client-utils'
 import { ActionModel, GenericContent } from '@sensenet/default-content-types'
 import { CommandProvider, SearchOptions } from '../CommandProviderManager'
 import { LocalizationService } from '../LocalizationService'
 import { SelectionService } from '../SelectionService'
 
+type ContentWithActionMetadata = GenericContent & {
+  __metadata?: {
+    actions?: MetadataAction[]
+    functions?: MetadataAction[]
+  }
+}
+
 export interface OnExecuteActionPayload {
   content: GenericContent
   action: ActionModel
@@ -24,13 +31,13 @@ export class CustomActionCommandProvider implements CommandProvider {
       : false
   }
 
-  private contentWithActionsAndMetadata: ODataResponse<GenericContent> | undefined
+  private contentWithActionsAndMetadata: ODataResponse<ContentWithActionMetadata> | undefined
 
   private async getActions(id: number, repository: Repository) {
     if (id === this.contentWithActionsAndMetadata?.d.Id) {
       return this.contentWithActionsAndMetadata
     }
-    const result = await repository.load<GenericContent>({
+    const result = await repository.load<ContentWithActionMetadata>({
       idOrPath: id,
       oDataOptions: {
         metadata: 'full',
@@ -42,6 +49,18 @@ export class CustomActionCommandProvider implements CommandProvider {
     return result
   }
 
+  public async getODataActionPayloads(
+    content: GenericContent,
+    repository: Repository,
+  ): Promise<OnExecuteActionPayload[]> {
+    const { d: contentWithActions } = await this.getActions(content.Id, repository)
+    const actions = Array.isArray(contentWithActions.Actions) ? (contentWithActions.Actions as ActionModel[]) : []
+
+    return actions
+      .filter((action) => action.IsODataAction && !action.Forbidden)
+      .map((action) => this.getActionPayload(content, contentWithActions, action))
+  }
+
   public async getItems(options: SearchOptions) {
     const content = this.selectionService.activeContent.getValue()
     const localization = this.localization.currentValues.getValue().commandPalette.customAction
@@ -50,40 +69,25 @@ export class CustomActionCommandProvider implements CommandProvider {
       return []
     }
 
-    const { d: contentWithActions } = await this.getActions(content.Id, options.repository)
-
-    return (contentWithActions.Actions as ActionModel[])
+    return (await this.getODataActionPayloads(content, options.repository))
       .filter(
-        (a) =>
-          (a.Name.toLowerCase().includes(filteredTerm) || a.DisplayName.toLowerCase().includes(filteredTerm)) &&
-          a.IsODataAction,
+        ({ action }) =>
+          action.Name.toLowerCase().includes(filteredTerm) ||
+          (action.DisplayName || action.Name).toLowerCase().includes(filteredTerm),
       )
-      .map((a) => {
-        const actionMetadata = contentWithActions.__metadata?.actions?.find((action) => action.opId === a.OpId)
-        const functionMetadata = contentWithActions.__metadata?.functions?.find((fn) => fn.opId === a.OpId)
-
-        // merge custom parameters to function metadata
-        const customActionMetadata = functionMetadata && {
-          ...functionMetadata,
-          ...this.addParametersForCustomActions(a),
-        }
-
+      .map((actionValue) => {
         return {
           primaryText: localization.executePrimaryText
             .replace('{0}', content.DisplayName || content.Name)
-            .replace('{1}', a.DisplayName || a.Name),
-          secondaryText: localization.executeSecondaryText.replace('{0}', content.Name).replace('{1}', a.Name),
-          parameters: a.ActionParameters,
+            .replace('{1}', actionValue.action.DisplayName || actionValue.action.Name),
+          secondaryText: localization.executeSecondaryText
+            .replace('{0}', content.Name)
+            .replace('{1}', actionValue.action.Name),
+          parameters: actionValue.action.ActionParameters,
           content,
           hits: [filteredTerm],
           url: '',
-          openAction: () =>
-            this.onExecuteAction.setValue({
-              action: a,
-              content,
-              metadata: actionMetadata || customActionMetadata,
-              method: actionMetadata ? 'POST' : 'GET',
-            }),
+          openAction: () => this.onExecuteAction.setValue(actionValue),
         }
       })
   }
@@ -110,4 +114,27 @@ export class CustomActionCommandProvider implements CommandProvider {
         return
     }
   }
+
+  private getActionPayload(
+    content: GenericContent,
+    contentWithActions: ContentWithActionMetadata,
+    action: ActionModel,
+  ): OnExecuteActionPayload {
+    const actionMetadata = contentWithActions.__metadata?.actions?.find(
+      (metadataAction) => metadataAction.opId === action.OpId,
+    )
+    const functionMetadata = contentWithActions.__metadata?.functions?.find((fn) => fn.opId === action.OpId)
+
+    const customActionMetadata = functionMetadata && {
+      ...functionMetadata,
+      ...this.addParametersForCustomActions(action),
+    }
+
+    return {
+      action,
+      content,
+      metadata: actionMetadata || customActionMetadata,
+      method: actionMetadata ? 'POST' : 'GET',
+    }
+  }
 }
diff --git a/apps/sensenet/src/services/EventService.ts b/apps/sensenet/src/services/EventService.ts
index 4417229ba..2d71de72a 100644
--- a/apps/sensenet/src/services/EventService.ts
+++ b/apps/sensenet/src/services/EventService.ts
@@ -10,6 +10,7 @@ export class EventService {
   public static storageDebounceInterval = 1000
 
   public static storageKey = `sn-app-eventservice-events`
+  private static maxStoredEventLogLength = 500000
 
   public dismiss(entry: EventLogEntry<any>) {
     this.values.setValue(
@@ -34,9 +35,56 @@ export class EventService {
   private storeChanges = debounce(() => {
     const values = [...this.values.getValue()]
     const entries = values.slice(values.length - this.personalSettings.effectiveValue.getValue().eventLogSize)
-    localStorage.setItem(EventService.storageKey, JSON.stringify(entries))
+    EventService.storeEntries(entries)
   }, EventService.storageDebounceInterval)
 
+  private static storeEntries(entries: Array<EventLogEntry<any>>) {
+    try {
+      localStorage.setItem(EventService.storageKey, JSON.stringify(entries))
+    } catch {
+      try {
+        localStorage.setItem(EventService.storageKey, JSON.stringify(EventService.getCompactEntries(entries)))
+      } catch {
+        localStorage.removeItem(EventService.storageKey)
+      }
+    }
+  }
+
+  private static getStoredEntries(): Array<EventLogEntry<any & { guid: string }>> {
+    const storedEntries = localStorage.getItem(EventService.storageKey)
+
+    if (!storedEntries) {
+      return []
+    }
+
+    if (storedEntries.length > EventService.maxStoredEventLogLength) {
+      localStorage.removeItem(EventService.storageKey)
+      return []
+    }
+
+    try {
+      const parsedEntries = JSON.parse(storedEntries)
+
+      return Array.isArray(parsedEntries) ? EventService.getCompactEntries(parsedEntries) : []
+    } catch {
+      localStorage.removeItem(EventService.storageKey)
+      return []
+    }
+  }
+
+  private static getCompactEntries(entries: Array<EventLogEntry<any>>) {
+    return entries.map((entry) => ({
+      ...entry,
+      data: {
+        added: entry.data?.added,
+        digestMessage: entry.data?.digestMessage,
+        guid: entry.data?.guid,
+        isDismissed: entry.data?.isDismissed,
+        multiple: entry.data?.multiple,
+      },
+    }))
+  }
+
   public add(...notifications: Array<EventLogEntry<any>>) {
     // const newValues = this.values.getValue().push())
     this.values.setValue([
@@ -54,7 +102,7 @@ export class EventService {
   }
 
   public values: ObservableValue<Array<EventLogEntry<any & { guid: string }>>> = new ObservableValue(
-    JSON.parse(localStorage.getItem(EventService.storageKey) || '[]') || [],
+    EventService.getStoredEntries(),
   )
 
   public notificationValues: ObservableValue<{ [key: string]: Array<EventLogEntry<any>> }> = new ObservableValue(
diff --git a/apps/sensenet/src/services/csv-export.ts b/apps/sensenet/src/services/csv-export.ts
new file mode 100644
index 000000000..76ffffffb
--- /dev/null
+++ b/apps/sensenet/src/services/csv-export.ts
@@ -0,0 +1,99 @@
+import { GenericContent } from '@sensenet/default-content-types'
+
+export const preferredCsvColumns = [
+  'Id',
+  'Path',
+  'Name',
+  'DisplayName',
+  'Type',
+  'CreatedBy',
+  'CreationDate',
+  'ModifiedBy',
+  'ModificationDate',
+  'Version',
+  'Index',
+]
+
+const excludedColumns = new Set(['Actions', 'Children', '__metadata'])
+
+const getColumnNames = (contents: GenericContent[]) => {
+  const columnNames = new Set<string>()
+
+  contents.forEach((content) => {
+    Object.keys(content).forEach((key) => {
+      if (!excludedColumns.has(key)) {
+        columnNames.add(key)
+      }
+    })
+  })
+
+  return [
+    ...preferredCsvColumns.filter((columnName) => columnNames.has(columnName)),
+    ...Array.from(columnNames)
+      .filter((columnName) => !preferredCsvColumns.includes(columnName))
+      .sort((left, right) => left.localeCompare(right)),
+  ]
+}
+
+const serializeValue = (value: unknown): string => {
+  if (value === undefined || value === null) {
+    return ''
+  }
+
+  if (value instanceof Date) {
+    return value.toISOString()
+  }
+
+  if (['string', 'number', 'boolean'].includes(typeof value)) {
+    return String(value)
+  }
+
+  if (Array.isArray(value)) {
+    return value.map((item) => serializeValue(item)).join('; ')
+  }
+
+  if (typeof value === 'object') {
+    const contentLikeValue = value as Partial<GenericContent>
+    return contentLikeValue.DisplayName || contentLikeValue.Name || contentLikeValue.Path || JSON.stringify(value)
+  }
+
+  return String(value)
+}
+
+const escapeCsvValue = (value: unknown) => {
+  const serializedValue = serializeValue(value)
+
+  return /[",\r\n;]/.test(serializedValue) ? `"${serializedValue.replace(/"/g, '""')}"` : serializedValue
+}
+
+export const createCsvFromContents = (contents: GenericContent[], selectedColumns?: string[]) => {
+  const columnNames = selectedColumns?.length ? selectedColumns : getColumnNames(contents)
+  const header = columnNames.map(escapeCsvValue).join(',')
+  const rows = contents.map((content) =>
+    columnNames.map((columnName) => escapeCsvValue((content as any)[columnName])).join(','),
+  )
+
+  return [header, ...rows].join('\r\n')
+}
+
+export const downloadCsv = (csvContent: string, fileName: string) => {
+  const blob = new Blob(['\uFEFF', csvContent], { type: 'text/csv;charset=utf-8' })
+  const url = URL.createObjectURL(blob)
+  const link = document.createElement('a')
+
+  link.href = url
+  link.download = fileName
+  link.style.display = 'none'
+  document.body.appendChild(link)
+  link.click()
+  document.body.removeChild(link)
+  URL.revokeObjectURL(url)
+}
+
+export const getCsvExportFileName = (contents: GenericContent[], parent?: GenericContent) => {
+  const parentName = parent?.Name || 'sensenet-content'
+  const timeStamp = new Date().toISOString().replace(/[:.]/g, '-')
+  const suffix = contents.length === 1 ? contents[0].Name || contents[0].Id : `${contents.length}-items`
+
+  return `${parentName}-${suffix}-${timeStamp}.csv`.replace(/[\\/:*?"<>|]/g, '_')
+}
diff --git a/apps/sensenet/src/services/execute-custom-action.ts b/apps/sensenet/src/services/execute-custom-action.ts
new file mode 100644
index 000000000..2f6dc008d
--- /dev/null
+++ b/apps/sensenet/src/services/execute-custom-action.ts
@@ -0,0 +1,38 @@
+import type { Repository } from '@sensenet/client-core'
+import { PathHelper } from '@sensenet/client-utils'
+import type { OnExecuteActionPayload } from './CommandProviders/CustomActionCommandProvider'
+
+export const executeCustomAction = async (repo: Repository, actionValue: OnExecuteActionPayload, postBody: string) => {
+  switch (actionValue.action.Name) {
+    case 'Load':
+      return await repo.load({ idOrPath: actionValue.content.Id, oDataOptions: { select: 'all' } })
+    case 'LoadCollection':
+      return await repo.loadCollection({ path: actionValue.content.Path })
+    case 'Create': {
+      const parsedBody = JSON.parse(postBody) as { contentType: string; content: object }
+      return await repo.post({
+        contentType: parsedBody.contentType,
+        parentPath: actionValue.content.IsFolder
+          ? actionValue.content.Path
+          : PathHelper.getParentPath(actionValue.content.Path),
+        content: parsedBody.content,
+      })
+    }
+    case 'Remove': {
+      const { permanent } = JSON.parse(postBody)
+      return await repo.delete({
+        idOrPath: actionValue.content.Id,
+        permanent: permanent == null ? false : permanent,
+      })
+    }
+    case 'Update':
+      return await repo.patch({ idOrPath: actionValue.content.Id, content: JSON.parse(postBody).content })
+    default:
+      return await repo.executeAction({
+        idOrPath: actionValue.content.Id,
+        body: JSON.parse(postBody),
+        method: actionValue.method,
+        name: actionValue.action.Name,
+      })
+  }
+}
diff --git a/apps/sensenet/src/services/zip-download.ts b/apps/sensenet/src/services/zip-download.ts
new file mode 100644
index 000000000..9536df347
--- /dev/null
+++ b/apps/sensenet/src/services/zip-download.ts
@@ -0,0 +1,399 @@
+import type { Repository } from '@sensenet/client-core'
+import type { GenericContent } from '@sensenet/default-content-types'
+
+type ZipEntry = {
+  path: string
+  data: Uint8Array
+  date: Date
+  isDirectory: boolean
+}
+
+type DownloadableContent = {
+  content: GenericContent
+  zipPath: string
+}
+
+export type ZipDownloadResult = {
+  fileCount: number
+  folderCount: number
+  skippedContentCount: number
+  fileName: string
+}
+
+type ZipDownloadOptions = {
+  repository: Repository
+  contents: GenericContent[]
+  parent?: GenericContent
+}
+
+const contentLoadBatchSize = 200
+const fileDownloadBatchSize = 4
+const zipUtf8Flag = 0x0800
+const zipVersionNeeded = 20
+const textEncoder = new TextEncoder()
+const invalidZipPathCharacters = new Set(['\\', '/', ':', '*', '?', '"', '<', '>', '|'])
+
+const crc32Table = (() => {
+  const table = new Uint32Array(256)
+
+  for (let index = 0; index < table.length; index++) {
+    let value = index
+
+    for (let bit = 0; bit < 8; bit++) {
+      value = value & 1 ? 0xedb88320 ^ (value >>> 1) : value >>> 1
+    }
+
+    table[index] = value >>> 0
+  }
+
+  return table
+})()
+
+const getCrc32 = (data: Uint8Array) => {
+  let crc = 0xffffffff
+
+  for (const byte of data) {
+    crc = (crc >>> 8) ^ crc32Table[(crc ^ byte) & 0xff]
+  }
+
+  return (crc ^ 0xffffffff) >>> 0
+}
+
+const getDosTime = (date: Date) => {
+  return (date.getHours() << 11) | (date.getMinutes() << 5) | Math.floor(date.getSeconds() / 2)
+}
+
+const getDosDate = (date: Date) => {
+  return ((date.getFullYear() - 1980) << 9) | ((date.getMonth() + 1) << 5) | date.getDate()
+}
+
+const getContentDate = (content: GenericContent) => {
+  const dateValue = content.ModificationDate || content.CreationDate
+  const date = dateValue ? new Date(dateValue) : new Date()
+
+  return Number.isNaN(date.getTime()) ? new Date() : date
+}
+
+const sanitizeZipPathSegment = (value: string | number | undefined) => {
+  const segment = String(value || 'content')
+    .split('')
+    .map((character) => (invalidZipPathCharacters.has(character) || character.charCodeAt(0) < 32 ? '_' : character))
+    .join('')
+    .trim()
+
+  return segment || 'content'
+}
+
+const getContentZipPathSegment = (content: GenericContent) => {
+  return sanitizeZipPathSegment(content.Name || content.DisplayName || content.Id)
+}
+
+const addDuplicateSuffix = (zipPath: string, index: number, isDirectory: boolean) => {
+  const pathWithoutTrailingSlash = isDirectory ? zipPath.replace(/\/$/, '') : zipPath
+  const slashIndex = pathWithoutTrailingSlash.lastIndexOf('/')
+  const parentPath = slashIndex >= 0 ? pathWithoutTrailingSlash.slice(0, slashIndex + 1) : ''
+  const fileName = slashIndex >= 0 ? pathWithoutTrailingSlash.slice(slashIndex + 1) : pathWithoutTrailingSlash
+  const dotIndex = !isDirectory ? fileName.lastIndexOf('.') : -1
+
+  if (dotIndex > 0) {
+    return `${parentPath}${fileName.slice(0, dotIndex)}(${index})${fileName.slice(dotIndex)}`
+  }
+
+  return `${parentPath}${fileName}(${index})${isDirectory ? '/' : ''}`
+}
+
+const reserveUniqueZipPath = (usedZipPaths: Set<string>, zipPath: string, isDirectory: boolean) => {
+  const normalizedZipPath = isDirectory ? `${zipPath.replace(/\/$/, '')}/` : zipPath
+  let nextZipPath = normalizedZipPath
+  let duplicateIndex = 1
+
+  while (usedZipPaths.has(nextZipPath)) {
+    nextZipPath = addDuplicateSuffix(normalizedZipPath, duplicateIndex, isDirectory)
+    duplicateIndex += 1
+  }
+
+  usedZipPaths.add(nextZipPath)
+
+  return nextZipPath
+}
+
+const createZipEntry = (path: string, data: Uint8Array, date: Date, isDirectory = false): ZipEntry => ({
+  path,
+  data,
+  date,
+  isDirectory,
+})
+
+const loadAllChildren = async (repository: Repository, path: string) => {
+  const children: GenericContent[] = []
+  let skip = 0
+  let hasMoreChildren = true
+
+  while (hasMoreChildren) {
+    const result = await repository.loadCollection<GenericContent>({
+      path,
+      oDataOptions: {
+        select: ['Id', 'Path', 'Name', 'DisplayName', 'Type', 'IsFile', 'IsFolder', 'CreationDate', 'ModificationDate'],
+        top: contentLoadBatchSize,
+        skip,
+        orderby: 'Name',
+      },
+    })
+    const loadedChildren = result.d.results
+
+    children.push(...loadedChildren)
+
+    hasMoreChildren = loadedChildren.length === contentLoadBatchSize
+    skip += contentLoadBatchSize
+  }
+
+  return children
+}
+
+const loadContentKindFields = async (repository: Repository, content: GenericContent) => {
+  if (content.IsFile !== undefined || content.IsFolder !== undefined) {
+    return content
+  }
+
+  const result = await repository.load<GenericContent>({
+    idOrPath: content.Id,
+    oDataOptions: {
+      select: ['Id', 'Path', 'Name', 'DisplayName', 'Type', 'IsFile', 'IsFolder', 'CreationDate', 'ModificationDate'],
+    },
+  })
+
+  return { ...content, ...result.d }
+}
+
+const fetchFileBytes = async (repository: Repository, content: GenericContent) => {
+  const headers = new Headers()
+
+  if (repository.configuration.token) {
+    headers.set('Authorization', `Bearer ${repository.configuration.token}`)
+  }
+
+  const response = await fetch(
+    `${repository.configuration.repositoryUrl}${content.Path}?download&t=${Date.now()}`,
+    headers.has('Authorization') ? { headers } : undefined,
+  )
+
+  if (!response.ok) {
+    throw new Error(`Failed to download ${content.Path}: ${response.status} ${response.statusText}`)
+  }
+
+  return new Uint8Array(await response.arrayBuffer())
+}
+
+const createLocalFileHeader = (entry: ZipEntry, fileNameBytes: Uint8Array, crc32: number) => {
+  const header = new Uint8Array(30 + fileNameBytes.length)
+  const view = new DataView(header.buffer)
+
+  view.setUint32(0, 0x04034b50, true)
+  view.setUint16(4, zipVersionNeeded, true)
+  view.setUint16(6, zipUtf8Flag, true)
+  view.setUint16(8, 0, true)
+  view.setUint16(10, getDosTime(entry.date), true)
+  view.setUint16(12, getDosDate(entry.date), true)
+  view.setUint32(14, crc32, true)
+  view.setUint32(18, entry.data.length, true)
+  view.setUint32(22, entry.data.length, true)
+  view.setUint16(26, fileNameBytes.length, true)
+  view.setUint16(28, 0, true)
+  header.set(fileNameBytes, 30)
+
+  return header
+}
+
+const createCentralDirectoryHeader = (
+  entry: ZipEntry,
+  fileNameBytes: Uint8Array,
+  crc32: number,
+  localHeaderOffset: number,
+) => {
+  const header = new Uint8Array(46 + fileNameBytes.length)
+  const view = new DataView(header.buffer)
+
+  view.setUint32(0, 0x02014b50, true)
+  view.setUint16(4, zipVersionNeeded, true)
+  view.setUint16(6, zipVersionNeeded, true)
+  view.setUint16(8, zipUtf8Flag, true)
+  view.setUint16(10, 0, true)
+  view.setUint16(12, getDosTime(entry.date), true)
+  view.setUint16(14, getDosDate(entry.date), true)
+  view.setUint32(16, crc32, true)
+  view.setUint32(20, entry.data.length, true)
+  view.setUint32(24, entry.data.length, true)
+  view.setUint16(28, fileNameBytes.length, true)
+  view.setUint16(30, 0, true)
+  view.setUint16(32, 0, true)
+  view.setUint16(34, 0, true)
+  view.setUint16(36, 0, true)
+  view.setUint32(38, entry.isDirectory ? 0x00100000 : 0, true)
+  view.setUint32(42, localHeaderOffset, true)
+  header.set(fileNameBytes, 46)
+
+  return header
+}
+
+const createEndOfCentralDirectory = (
+  entryCount: number,
+  centralDirectorySize: number,
+  centralDirectoryOffset: number,
+) => {
+  const header = new Uint8Array(22)
+  const view = new DataView(header.buffer)
+
+  view.setUint32(0, 0x06054b50, true)
+  view.setUint16(4, 0, true)
+  view.setUint16(6, 0, true)
+  view.setUint16(8, entryCount, true)
+  view.setUint16(10, entryCount, true)
+  view.setUint32(12, centralDirectorySize, true)
+  view.setUint32(16, centralDirectoryOffset, true)
+  view.setUint16(20, 0, true)
+
+  return header
+}
+
+const createZipBlob = (entries: ZipEntry[]) => {
+  if (entries.length > 0xffff) {
+    throw new Error('Too many ZIP entries. ZIP64 is not supported by this exporter.')
+  }
+
+  const localFileParts: Uint8Array[] = []
+  const centralDirectoryParts: Uint8Array[] = []
+  let localFileOffset = 0
+
+  entries.forEach((entry) => {
+    const fileNameBytes = textEncoder.encode(entry.path)
+    const crc32 = getCrc32(entry.data)
+    const localFileHeader = createLocalFileHeader(entry, fileNameBytes, crc32)
+    const centralDirectoryHeader = createCentralDirectoryHeader(entry, fileNameBytes, crc32, localFileOffset)
+
+    localFileParts.push(localFileHeader, entry.data)
+    centralDirectoryParts.push(centralDirectoryHeader)
+    localFileOffset += localFileHeader.length + entry.data.length
+  })
+
+  const centralDirectoryOffset = localFileOffset
+  const centralDirectorySize = centralDirectoryParts.reduce((totalSize, part) => totalSize + part.length, 0)
+  const endOfCentralDirectory = createEndOfCentralDirectory(
+    entries.length,
+    centralDirectorySize,
+    centralDirectoryOffset,
+  )
+
+  return new Blob([...localFileParts, ...centralDirectoryParts, endOfCentralDirectory], { type: 'application/zip' })
+}
+
+const downloadBlob = (blob: Blob, fileName: string) => {
+  const url = URL.createObjectURL(blob)
+  const link = document.createElement('a')
+
+  link.href = url
+  link.download = fileName
+  link.style.display = 'none'
+  document.body.appendChild(link)
+  link.click()
+  document.body.removeChild(link)
+  URL.revokeObjectURL(url)
+}
+
+export const getZipDownloadFileName = (contents: GenericContent[], parent?: GenericContent) => {
+  const parentName = sanitizeZipPathSegment(parent?.Name || 'sensenet-content')
+  const timeStamp = new Date().toISOString().replace(/[:.]/g, '-')
+  const suffix =
+    contents.length === 1 ? sanitizeZipPathSegment(contents[0].Name || contents[0].Id) : `${contents.length}-items`
+
+  return `${parentName}-${suffix}-${timeStamp}.zip`
+}
+
+export const downloadContentsAsZip = async ({
+  repository,
+  contents,
+  parent,
+}: ZipDownloadOptions): Promise<ZipDownloadResult> => {
+  const zipEntries: ZipEntry[] = []
+  const filesToDownload: DownloadableContent[] = []
+  const visitedContentIds = new Set<number>()
+  const usedZipPaths = new Set<string>()
+  let folderCount = 0
+  let skippedContentCount = 0
+
+  const collectContent = async (content: GenericContent, parentZipPath = ''): Promise<void> => {
+    if (visitedContentIds.has(content.Id)) {
+      return
+    }
+
+    const contentWithKind = await loadContentKindFields(repository, content)
+
+    if (visitedContentIds.has(contentWithKind.Id)) {
+      return
+    }
+
+    visitedContentIds.add(contentWithKind.Id)
+
+    const zipPath = parentZipPath
+      ? `${parentZipPath}/${getContentZipPathSegment(contentWithKind)}`
+      : getContentZipPathSegment(contentWithKind)
+
+    if (contentWithKind.IsFolder) {
+      const uniqueDirectoryPath = reserveUniqueZipPath(usedZipPaths, zipPath, true)
+      zipEntries.push(createZipEntry(uniqueDirectoryPath, new Uint8Array(), getContentDate(contentWithKind), true))
+      folderCount += 1
+
+      const children = await loadAllChildren(repository, contentWithKind.Path)
+
+      for (const child of children) {
+        await collectContent(child, uniqueDirectoryPath.replace(/\/$/, ''))
+      }
+
+      return
+    }
+
+    if (contentWithKind.IsFile) {
+      filesToDownload.push({
+        content: contentWithKind,
+        zipPath: reserveUniqueZipPath(usedZipPaths, zipPath, false),
+      })
+
+      return
+    }
+
+    skippedContentCount += 1
+  }
+
+  for (const content of contents) {
+    await collectContent(content)
+  }
+
+  for (let startIndex = 0; startIndex < filesToDownload.length; startIndex += fileDownloadBatchSize) {
+    const batch = filesToDownload.slice(startIndex, startIndex + fileDownloadBatchSize)
+    const downloadedFiles = await Promise.all(
+      batch.map(async (file) => ({
+        file,
+        bytes: await fetchFileBytes(repository, file.content),
+      })),
+    )
+
+    downloadedFiles.forEach(({ file, bytes }) => {
+      zipEntries.push(createZipEntry(file.zipPath, bytes, getContentDate(file.content)))
+    })
+  }
+
+  if (!zipEntries.length) {
+    throw new Error('There is no downloadable content in the current selection.')
+  }
+
+  const fileName = getZipDownloadFileName(contents, parent)
+  const zipBlob = createZipBlob(zipEntries)
+
+  downloadBlob(zipBlob, fileName)
+
+  return {
+    fileCount: filesToDownload.length,
+    folderCount,
+    skippedContentCount,
+    fileName,
+  }
+}
diff --git a/apps/sensenet/webpack.common.js b/apps/sensenet/webpack.common.js
index ea654e0f1..5fbcf7c31 100644
--- a/apps/sensenet/webpack.common.js
+++ b/apps/sensenet/webpack.common.js
@@ -2,12 +2,38 @@ const path = require('path')
 const MonacoWebpackPlugin = require('monaco-editor-webpack-plugin')
 const webpack = require('webpack')
 
+const packageSourceAliases = {
+  '@sensenet/authentication-oidc-react$': path.resolve(
+    __dirname,
+    '../../packages/sn-authentication-oidc-react/src/index.ts',
+  ),
+  '@sensenet/client-core$': path.resolve(__dirname, '../../packages/sn-client-core/src/index.ts'),
+  '@sensenet/client-utils$': path.resolve(__dirname, '../../packages/sn-client-utils/src/index.ts'),
+  '@sensenet/control-mapper$': path.resolve(__dirname, '../../packages/sn-control-mapper/src/index.ts'),
+  '@sensenet/controls-react$': path.resolve(__dirname, '../../packages/sn-controls-react/src/index.ts'),
+  '@sensenet/default-content-types$': path.resolve(__dirname, '../../packages/sn-default-content-types/src/index.ts'),
+  '@sensenet/document-viewer-react$': path.resolve(__dirname, '../../packages/sn-document-viewer-react/src/index.ts'),
+  '@sensenet/editor-react$': path.resolve(__dirname, '../../packages/sn-editor-react/src/index.ts'),
+  '@sensenet/hooks-react$': path.resolve(__dirname, '../../packages/sn-hooks-react/src/index.ts'),
+  '@sensenet/icons-react$': path.resolve(__dirname, '../../packages/sn-icons-react/src/index.ts'),
+  '@sensenet/list-controls-react$': path.resolve(
+    __dirname,
+    '../../packages/sn-list-controls-react/src/ContentList/index.ts',
+  ),
+  '@sensenet/pickers-react$': path.resolve(__dirname, '../../packages/sn-pickers-react/src/index.ts'),
+  '@sensenet/query$': path.resolve(__dirname, '../../packages/sn-query/src/index.ts'),
+  '@sensenet/repository-events$': path.resolve(__dirname, '../../packages/sn-repository-events/src/index.ts'),
+  '@sensenet/search-react$': path.resolve(__dirname, '../../packages/sn-search-react/src/index.ts'),
+  '@sensenet/sn-auth-react$': path.resolve(__dirname, '../../packages/sn-auth-react/src/index.ts'),
+}
+
 module.exports = {
   output: {
     path: path.resolve(__dirname, 'build'),
     publicPath: '/',
   },
   resolve: {
+    alias: packageSourceAliases,
     extensions: ['.ts', '.tsx', '.js', '.json'],
   },
   module: {
diff --git a/docker-compose.dev.yml b/docker-compose.dev.yml
index a133c9fef..e12154e57 100644
--- a/docker-compose.dev.yml
+++ b/docker-compose.dev.yml
@@ -16,7 +16,7 @@ services:
       - .:/app
       - sensenet-root-node-modules:/app/node_modules
       - sensenet-app-node-modules:/app/apps/sensenet/node_modules
-    command: sh -c "yarn build && yarn snapp start"
+    command: sh -c "yarn snapp start"
     healthcheck:
       test: [ "CMD", "wget", "--no-verbose", "--tries=1", "--spider", "http://127.0.0.1:8080/" ]
       interval: 30s
diff --git a/packages/sn-editor-react/src/tinymce/Editor.tsx b/packages/sn-editor-react/src/tinymce/Editor.tsx
index d791bfb8a..80727b5de 100644
--- a/packages/sn-editor-react/src/tinymce/Editor.tsx
+++ b/packages/sn-editor-react/src/tinymce/Editor.tsx
@@ -107,6 +107,8 @@ export const TinymceEditor: FC<TinymceEditorProps> = (props) => {
           height: 500,
           menubar: true,
           automatic_uploads: true,
+          relative_urls: false,
+          remove_script_host: true,
           image_title: true,
           plugins: [
             'advlist',
diff --git a/packages/sn-editor-react/src/tinymce/controls/repo-file-plugin.tsx b/packages/sn-editor-react/src/tinymce/controls/repo-file-plugin.tsx
index 48e2919f3..3042aeae4 100644
--- a/packages/sn-editor-react/src/tinymce/controls/repo-file-plugin.tsx
+++ b/packages/sn-editor-react/src/tinymce/controls/repo-file-plugin.tsx
@@ -47,6 +47,7 @@ import { Repository } from '@sensenet/client-core'
 import { File } from '@sensenet/default-content-types'
 import { PickerAdvanced } from '@sensenet/pickers-react'
 import React, { useEffect, useRef } from 'react'
+import { createRepoFileDownloadMarkup } from './repo-file-plugin.utils'
 
 const useStyles = makeStyles(() => {
   return createStyles({
@@ -81,14 +82,7 @@ export const RepoFilePluginControl: React.FC<RepoFilePluginControlProps> = ({
   const handleInsert = (selection: File[]) => {
     const content = selection
       .filter((item) => item.IsFile)
-      .map((item) => {
-        const size = item.Size ? `(${(item.Size / 1024).toFixed(0)} KB)` : ''
-        return `<div class="download">
-          <div>${item.DisplayName}</div>
-          <a href="${item.Path}" target="_blank" rel="noopener">Download</a> ${size}
-          </div>
-          <p>&nbsp;</p>`
-      })
+      .map((item) => createRepoFileDownloadMarkup(item))
       .join('')
 
     editor.execCommand('mceInsertContent', false, content)
diff --git a/packages/sn-editor-react/src/tinymce/controls/repo-file-plugin.utils.ts b/packages/sn-editor-react/src/tinymce/controls/repo-file-plugin.utils.ts
new file mode 100644
index 000000000..189446eb9
--- /dev/null
+++ b/packages/sn-editor-react/src/tinymce/controls/repo-file-plugin.utils.ts
@@ -0,0 +1,20 @@
+import type { File } from '@sensenet/default-content-types'
+
+type RepoFileLinkItem = Pick<File, 'DisplayName' | 'Path' | 'Size'>
+
+export const normalizeRepositoryFileUrl = (url?: string) => {
+  return (url ?? '')
+    .replace(/^(?:\.\.\/)+Root(?=\/|$)/, '/Root')
+    .replace(/^Root(?=\/|$)/, '/Root')
+}
+
+export const createRepoFileDownloadMarkup = (item: RepoFileLinkItem) => {
+  const size = item.Size ? `(${(item.Size / 1024).toFixed(0)} KB)` : ''
+  const href = normalizeRepositoryFileUrl(item.Path)
+
+  return `<div class="download">
+          <div>${item.DisplayName}</div>
+          <a href="${href}" target="_blank" rel="noopener">Download</a> ${size}
+          </div>
+          <p>&nbsp;</p>`
+}
diff --git a/packages/sn-editor-react/test/repo-file-plugin.test.tsx b/packages/sn-editor-react/test/repo-file-plugin.test.tsx
new file mode 100644
index 000000000..c4f27f642
--- /dev/null
+++ b/packages/sn-editor-react/test/repo-file-plugin.test.tsx
@@ -0,0 +1,25 @@
+import {
+  createRepoFileDownloadMarkup,
+  normalizeRepositoryFileUrl,
+} from '../src/tinymce/controls/repo-file-plugin.utils'
+
+describe('repo file plugin utils', () => {
+  it('should normalize repository file urls to root-relative paths', () => {
+    expect(normalizeRepositoryFileUrl('../Root/Content/file.pdf')).toBe('/Root/Content/file.pdf')
+    expect(normalizeRepositoryFileUrl('../../Root/Content/file.pdf')).toBe('/Root/Content/file.pdf')
+    expect(normalizeRepositoryFileUrl('Root/Content/file.pdf')).toBe('/Root/Content/file.pdf')
+    expect(normalizeRepositoryFileUrl('/Root/Content/file.pdf')).toBe('/Root/Content/file.pdf')
+  })
+
+  it('should create download markup with a normalized repository href', () => {
+    const markup = createRepoFileDownloadMarkup({
+      DisplayName: 'file.pdf',
+      Path: '../Root/Content/file.pdf',
+      Size: 2048,
+    })
+
+    expect(markup).toContain(
+      '<a href="/Root/Content/file.pdf" target="_blank" rel="noopener">Download</a> (2 KB)',
+    )
+  })
+})
diff --git a/packages/sn-hooks-react/src/context/current-children.tsx b/packages/sn-hooks-react/src/context/current-children.tsx
index 19a629f8f..1ecfcdcc2 100644
--- a/packages/sn-hooks-react/src/context/current-children.tsx
+++ b/packages/sn-hooks-react/src/context/current-children.tsx
@@ -12,6 +12,9 @@ import { LoadSettingsContext } from './load-settings'
 export const CurrentChildrenContext = createContext<GenericContent[]>([])
 CurrentChildrenContext.displayName = 'CurrentChildrenContext'
 
+export const CurrentChildrenIsLoadingContext = createContext<boolean>(false)
+CurrentChildrenIsLoadingContext.displayName = 'CurrentChildrenIsLoadingContext'
+
 export interface CurrentChildrenProviderProps {
   loadSettings?: ODataParams<GenericContent>
   alwaysRefresh?: boolean
@@ -25,6 +28,7 @@ export interface CurrentChildrenProviderProps {
 export const CurrentChildrenProvider: FunctionComponent<CurrentChildrenProviderProps> = (props) => {
   const currentContent = useContext(CurrentContentContext)
   const [children, setChildren] = useState<GenericContent[]>([])
+  const [isLoading, setIsLoading] = useState(false)
 
   const alwaysRefresh = props.alwaysRefresh || currentContent.Type === 'SmartFolder'
 
@@ -38,23 +42,41 @@ export const CurrentChildrenProvider: FunctionComponent<CurrentChildrenProviderP
 
   useEffect(() => {
     const ac = new AbortController()
+    let isCurrentRequest = true
     ;(async () => {
-      if (currentContent.Path) {
-        try {
-          const childrenResult = await repo.loadCollection<GenericContent>({
-            path: currentContent.Path,
-            requestInit: { signal: ac.signal },
-            oDataOptions: deepMerge(loadSettings.loadChildrenSettings, props.loadSettings),
-          })
+      if (!currentContent.Path) {
+        setChildren([])
+        setIsLoading(false)
+        return
+      }
+
+      setError(undefined)
+      setIsLoading(true)
+
+      try {
+        const childrenResult = await repo.loadCollection<GenericContent>({
+          path: currentContent.Path,
+          requestInit: { signal: ac.signal },
+          oDataOptions: deepMerge(loadSettings.loadChildrenSettings, props.loadSettings),
+        })
+
+        if (isCurrentRequest) {
           setChildren(childrenResult.d.results)
-        } catch (err) {
-          if (!ac.signal.aborted) {
-            setError(err)
-          }
+        }
+      } catch (err) {
+        if (isCurrentRequest && !ac.signal.aborted) {
+          setError(err)
+        }
+      } finally {
+        if (isCurrentRequest) {
+          setIsLoading(false)
         }
       }
     })()
-    return () => ac.abort()
+    return () => {
+      isCurrentRequest = false
+      ac.abort()
+    }
   }, [currentContent.Path, loadSettings.loadChildrenSettings, props.loadSettings, repo, reloadToken])
 
   useEffect(() => {
@@ -152,5 +174,9 @@ export const CurrentChildrenProvider: FunctionComponent<CurrentChildrenProviderP
     throw error
   }
 
-  return <CurrentChildrenContext.Provider value={children}>{props.children}</CurrentChildrenContext.Provider>
+  return (
+    <CurrentChildrenIsLoadingContext.Provider value={isLoading}>
+      <CurrentChildrenContext.Provider value={children}>{props.children}</CurrentChildrenContext.Provider>
+    </CurrentChildrenIsLoadingContext.Provider>
+  )
 }