diff --git a/package-lock.json b/package-lock.json
index 36a7367..ea12a2a 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -16,9 +16,7 @@
         "monaco-editor": "^0.49.0",
         "react": "^18.3.1",
         "react-dom": "^18.3.1",
-        "react-icons": "^5.2.0",
-        "zod": "^3.23.8",
-        "zod-error": "^1.5.0"
+        "react-icons": "^5.2.0"
       },
       "devDependencies": {
         "@types/react": "^18.3.3",
@@ -2244,24 +2242,6 @@
       "integrity": "sha512-a4UGQaWPH59mOXUYnAG2ewncQS4i4F43Tv3JoAM+s2VDAmS9NsK8GpDMLrCHPksFT7h3K6TOoUNn2pb7RoXx4g==",
       "dev": true,
       "license": "ISC"
-    },
-    "node_modules/zod": {
-      "version": "3.23.8",
-      "resolved": "https://registry.npmjs.org/zod/-/zod-3.23.8.tgz",
-      "integrity": "sha512-XBx9AXhXktjUqnepgTiE5flcKIYWi/rme0Eaj+5Y0lftuGBq+jyRu/md4WnuxqgP1ubdpNCsYEYPxrzVHD8d6g==",
-      "license": "MIT",
-      "funding": {
-        "url": "https://github.com/sponsors/colinhacks"
-      }
-    },
-    "node_modules/zod-error": {
-      "version": "1.5.0",
-      "resolved": "https://registry.npmjs.org/zod-error/-/zod-error-1.5.0.tgz",
-      "integrity": "sha512-zzopKZ/skI9iXpqCEPj+iLCKl9b88E43ehcU+sbRoHuwGd9F1IDVGQ70TyO6kmfiRL1g4IXkjsXK+g1gLYl4WQ==",
-      "license": "MIT",
-      "dependencies": {
-        "zod": "^3.20.2"
-      }
     }
   }
 }
diff --git a/package.json b/package.json
index 032d883..d17bcaf 100644
--- a/package.json
+++ b/package.json
@@ -18,9 +18,7 @@
     "monaco-editor": "^0.49.0",
     "react": "^18.3.1",
     "react-dom": "^18.3.1",
-    "react-icons": "^5.2.0",
-    "zod": "^3.23.8",
-    "zod-error": "^1.5.0"
+    "react-icons": "^5.2.0"
   },
   "devDependencies": {
     "@types/react": "^18.3.3",
diff --git a/src/App.tsx b/src/App.tsx
index 6d3a9e6..c90deb1 100644
--- a/src/App.tsx
+++ b/src/App.tsx
@@ -1,6 +1,5 @@
 import {
   ActionIcon,
-  Badge,
   Box,
   Button,
   Flex,
@@ -8,23 +7,27 @@ import {
   useMantineTheme,
 } from '@mantine/core'
 import {notifications} from '@mantine/notifications'
-import Editor, {loader} from '@monaco-editor/react'
+import Editor, {Monaco, loader, useMonaco} from '@monaco-editor/react'
 import LZString from 'lz-string'
 import {editor} from 'monaco-editor'
-import {useState} from 'react'
+import {useEffect, useState} from 'react'
 import {FiAlertCircle, FiLink} from 'react-icons/fi'
 import {LuEraser} from 'react-icons/lu'
-import {ZodSchema, z} from 'zod'
 
-import zodTypes from '../node_modules/zod/lib/types.d.ts?raw'
-import {dependencies} from '../package.json'
 import classes from './App.module.css'
 import {CopyButton} from './features/CopyButton'
 import {Validation} from './features/ValueEditor/ValueEditor'
-import {AppData, appDataSchema} from './types'
+import {VersionPicker} from './features/VersionPicker/VersionPicker'
 import {Header} from './ui/Header/Header'
+import * as zod from './zod'
 
-const ZOD_VERSION = dependencies.zod.split('^')[1]
+type AppData = {
+  schema: string
+  values: string[]
+  version: string
+}
+
+const ZOD_DEFAULT_VERSION = (await zod.getVersions('latest'))[0]
 
 const editorOptions: editor.IStandaloneEditorConstructionOptions = {
   minimap: {enabled: false},
@@ -46,14 +49,10 @@ const editorOptions: editor.IStandaloneEditorConstructionOptions = {
   renderLineHighlight: 'none',
 }
 
-loader.init().then((monaco) => {
-  monaco.languages.typescript.typescriptDefaults.addExtraLib(
-    `declare namespace z{${zodTypes}}`,
-  )
-  monaco.languages.typescript.typescriptDefaults.setDiagnosticsOptions({
-    noSemanticValidation: true,
-    noSyntaxValidation: true,
-  })
+const monaco = await loader.init()
+monaco.languages.typescript.typescriptDefaults.setDiagnosticsOptions({
+  noSemanticValidation: true,
+  noSyntaxValidation: true,
 })
 
 const getAppDataFromSearchParams = (): AppData => {
@@ -64,13 +63,14 @@ const getAppDataFromSearchParams = (): AppData => {
     return {
       schema: '',
       values: [],
+      version: ZOD_DEFAULT_VERSION,
     }
 
   const decompressedAppData =
     LZString.decompressFromEncodedURIComponent(compressedAppData)
   const appData = JSON.parse(decompressedAppData)
 
-  return appDataSchema.parse(appData)
+  return appData
 }
 
 const getURLwithAppData = (appData: AppData): string => {
@@ -83,24 +83,6 @@ const getURLwithAppData = (appData: AppData): string => {
   return `${window.location.protocol}//${window.location.host}?${queryParams}`
 }
 
-const schemaSchema = z
-  .string()
-  .min(2)
-  .transform((s, ctx) => {
-    try {
-      return eval(s)
-    } catch (e) {
-      const errorMessage = e instanceof Error ? e.message : 'Invalid schema'
-
-      ctx.addIssue({
-        code: z.ZodIssueCode.custom,
-        message: errorMessage,
-      })
-      return z.NEVER
-    }
-  })
-  .pipe(z.custom<ZodSchema>())
-
 const sampleZodSchema = `z.object({
   name: z.string(),
   birth_year: z.number().optional()
@@ -110,15 +92,14 @@ const sampleValue = '{name: "John"}'
 
 const appData = getAppDataFromSearchParams()
 
-const evaluateSchema = (schema: string) => {
-  try {
-    const evaluatedSchema = schemaSchema.parse(schema)
-    return {evaluatedSchema}
-  } catch (e) {
-    if (e instanceof z.ZodError) return {error: e.message}
+const setMonacoDeclarationTypes = async (monaco: Monaco, ver: string) => {
+  const declarationTypes = await zod.getDeclarationTypes(ver)
 
-    return {error: 'Invalid schema'}
-  }
+  monaco.languages.typescript.typescriptDefaults.setExtraLibs([
+    {
+      content: `declare namespace z{${declarationTypes}}`,
+    },
+  ])
 }
 
 const App = () => {
@@ -130,10 +111,29 @@ const App = () => {
     return appData.values.length ? appData.values : [sampleValue]
   })
 
-  const {evaluatedSchema, error: schemaError} = evaluateSchema(schema)
+  const [isLoading, setIsLoading] = useState<boolean>(false)
+
+  const [version, setVersion] = useState(appData.version || ZOD_DEFAULT_VERSION)
+
+  const monaco = useMonaco()
+
+  const {data: evaluatedSchema, error: schemaError} = zod.validateSchema(schema)
 
   const theme = useMantineTheme()
 
+  useEffect(() => {
+    if (isLoading || !monaco) return
+
+    async function updateVersion(monaco: Monaco, ver: string) {
+      setIsLoading(true)
+      await zod.setVersion(ver)
+      await setMonacoDeclarationTypes(monaco, ver)
+      setIsLoading(false)
+    }
+
+    updateVersion(monaco, version)
+  }, [version, monaco])
+
   return (
     <Box className={classes.layout}>
       <Header>
@@ -147,6 +147,7 @@ const App = () => {
               const urlWithAppData = getURLwithAppData({
                 schema,
                 values: values.filter((value) => typeof value == 'string'),
+                version,
               })
               navigator.clipboard.writeText(urlWithAppData)
               notifications.show({
@@ -172,9 +173,13 @@ const App = () => {
           >
             <Flex gap="sm" align="center" flex={1}>
               Zod schema
-              <Badge variant="default" size="lg" tt="none">
-                v{ZOD_VERSION}
-              </Badge>
+              <VersionPicker
+                value={version}
+                onChange={async (ver) => {
+                  setVersion(ver)
+                }}
+                disabled={isLoading}
+              />
               <Button
                 rel="noopener noreferrer"
                 target="_blank"
diff --git a/src/features/ValueEditor/ValueEditor.tsx b/src/features/ValueEditor/ValueEditor.tsx
index f71657e..b70923b 100644
--- a/src/features/ValueEditor/ValueEditor.tsx
+++ b/src/features/ValueEditor/ValueEditor.tsx
@@ -21,75 +21,9 @@ import {
   FiPlus,
 } from 'react-icons/fi'
 import {LuEraser} from 'react-icons/lu'
-import {ZodSchema, z} from 'zod'
-import {generateErrorMessage} from 'zod-error'
 import {CopyButton} from '../CopyButton'
 import classes from './ValueEditor.module.css'
-
-const getErrorMessage = (e: unknown) => {
-  if (e instanceof SyntaxError) {
-    return 'Invalid syntax'
-  }
-
-  if (e instanceof ReferenceError) {
-    return 'Invalid reference'
-  }
-
-  return 'Invalid value'
-}
-
-const evaluateExpression = (expression: string) => {
-  try {
-    const evaluatedExpression = new Function(`return ${expression}`)()
-    return {success: true, data: evaluatedExpression} as const
-  } catch (e) {
-    return {
-      success: false,
-      error: getErrorMessage(e),
-    } as const
-  }
-}
-
-type ValidationResult =
-  | {
-      success: false
-      error: string
-    }
-  | {
-      success: true
-      parsedData: any
-    }
-
-const validateValue = (
-  schema: ZodSchema<any, z.ZodTypeDef, any> | undefined,
-  value: string,
-): ValidationResult => {
-  if (!schema) {
-    return {
-      success: false,
-      error: 'Invalid Schema',
-    }
-  }
-
-  const evaluatedValue = evaluateExpression(value)
-  if (!evaluatedValue.success) return evaluatedValue
-
-  try {
-    const validationRes = schema.safeParse(evaluatedValue.data)
-
-    return validationRes.success
-      ? ({success: true, parsedData: validationRes.data} as const)
-      : ({
-          success: false,
-          error: generateErrorMessage(validationRes.error.issues),
-        } as const)
-  } catch (e) {
-    return {
-      success: false,
-      error: 'Cannot validate value. Please check the schema',
-    }
-  }
-}
+import * as zod from '../../zod'
 
 const editorOptions: editor.IStandaloneEditorConstructionOptions = {
   minimap: {enabled: false},
@@ -114,7 +48,7 @@ const editorOptions: editor.IStandaloneEditorConstructionOptions = {
 }
 
 interface Props {
-  schema: ZodSchema<any, z.ZodTypeDef, any> | undefined
+  schema: any
   value: string
   index: number
   onAdd: () => void
@@ -135,8 +69,8 @@ export const Validation = ({
   const [opened, {close, open}] = useDisclosure(false)
   const [openedResult, {toggle: toggleResult}] = useDisclosure(false)
 
-  const validation = validateValue(schema, value)
-  const parsedData = validation.success && JSON.stringify(validation.parsedData)
+  const validation = zod.validateValue(schema, value)
+  const parsedData = validation.success && JSON.stringify(validation.data)
 
   const errors = !validation.success && JSON.stringify(validation.error)
 
diff --git a/src/features/VersionPicker/VersionPicker.tsx b/src/features/VersionPicker/VersionPicker.tsx
new file mode 100644
index 0000000..12d9c33
--- /dev/null
+++ b/src/features/VersionPicker/VersionPicker.tsx
@@ -0,0 +1,95 @@
+import {Badge, Combobox, Loader, useCombobox} from '@mantine/core'
+import {useEffect, useState} from 'react'
+import {FiChevronDown} from 'react-icons/fi'
+import * as zod from '../../zod'
+
+export function VersionPicker({
+  value,
+  onChange,
+  disabled,
+}: {
+  value: string
+  onChange: (value: string) => void
+  disabled: boolean
+}) {
+  const combobox = useCombobox({
+    onDropdownClose: () => {
+      combobox.resetSelectedOption()
+      combobox.focusTarget()
+      setSearchValue('')
+    },
+
+    onDropdownOpen: () => {
+      combobox.focusSearchInput()
+    },
+  })
+
+  const [loading, setLoading] = useState(false)
+  const [versions, setVersions] = useState<string[] | null>(null)
+  const [searchValue, setSearchValue] = useState('')
+
+  useEffect(() => {
+    setLoading(true)
+
+    zod.getVersions()
+      .then((versions) => {
+        setVersions(versions)
+      })
+      .finally(() => {
+        setLoading(false)
+      })
+  }, [])
+
+  const options = (versions || []).map((item) => (
+    <Combobox.Option value={item} key={item}>
+      {item}
+    </Combobox.Option>
+  ))
+
+  return (
+    <Combobox
+      width={300}
+      onOptionSubmit={(optionValue) => {
+        onChange(optionValue)
+        setSearchValue(optionValue)
+        combobox.closeDropdown()
+      }}
+      withinPortal={false}
+      store={combobox}
+      position="bottom-start"
+      withArrow
+    >
+      <Combobox.Target>
+        <Badge
+          variant="default"
+          size="lg"
+          tt="none"
+          onClick={() => combobox.toggleDropdown()}
+          component="button"
+          rightSection={
+            loading ? <Loader size={18} /> : <FiChevronDown size={18} />
+          }
+          disabled={disabled}
+          style={{opacity: disabled ? 0.5 : 1}}
+        >
+          v{value}
+        </Badge>
+      </Combobox.Target>
+
+      <Combobox.Dropdown hidden={versions === null}>
+        <Combobox.Search
+          placeholder="Search a version"
+          value={searchValue}
+          onChange={(event) => {
+            setSearchValue(event.currentTarget.value)
+            combobox.resetSelectedOption()
+          }}
+        />
+        <Combobox.Options mah={400} style={{overflowY: 'auto'}}>
+          {options}
+          {versions?.length === 0 && <Combobox.Empty>No results found</Combobox.Empty>}
+        </Combobox.Options>
+      </Combobox.Dropdown>
+    </Combobox>
+  )
+}
diff --git a/src/types.ts b/src/types.ts
deleted file mode 100644
index bf1123f..0000000
--- a/src/types.ts
+++ /dev/null
@@ -1,13 +0,0 @@
-import {z} from 'zod'
-
-export const appDataSchema = z.object({
-  schema: z.string(),
-  values: z.array(z.string()),
-})
-
-export type AppData = z.infer<typeof appDataSchema>
-
-export type Validation = {
-  value?: string
-  result?: {success: true; data: unknown} | {success: false; error: string}
-}
diff --git a/src/zod.ts b/src/zod.ts
new file mode 100644
index 0000000..86bca7e
--- /dev/null
+++ b/src/zod.ts
@@ -0,0 +1,112 @@
+export type ZodValidation = {
+  success: boolean
+  data?: any
+  error?: string
+}
+
+let _metadata: any
+let _z: any
+
+export async function getDeclarationTypes(ver: string): Promise<string> {
+  const res = await fetch(`https://cdn.jsdelivr.net/npm/zod@${ver}/lib/types.d.ts`)
+  return await res.text()
+}
+
+export async function getVersions(tag?: string): Promise<string[]> {
+  if (!_metadata) {
+    const res = await fetch('https://data.jsdelivr.com/v1/packages/npm/zod')
+    _metadata = await res.json()
+  }
+
+  if (tag) {
+    const ver = _metadata.tags[tag]
+    if (ver) return [ver]
+    else throw new Error('Invalid tag')
+  }
+
+  const versions = []
+  for (const el of _metadata.versions) {
+    const ver = el.version
+
+    if (ver.startsWith('1'))
+      continue
+
+    if (['alpha', 'beta', 'canary'].some((v) => ver.includes(v)))
+      continue
+    
+    versions.push(ver)
+  }
+
+  versions.push(_metadata.tags.canary)
+
+  return versions.toSorted((a, b) => b.localeCompare(a, undefined, {numeric: true}))
+}
+
+export async function setVersion(ver: string) {
+  _z = await import(
+    /* @vite-ignore */ `https://cdn.jsdelivr.net/npm/zod@${ver}/+esm`
+  )
+}
+
+export function validateSchema(schema: string): ZodValidation {
+  try {
+    if (schema.length < 3) throw new Error('Schema is too short')
+
+    const data = new Function('z', `return ${schema}`)(_z)
+
+    return {
+      success: true,
+      data,
+    }
+  } catch (e: any) {
+    return {
+      success: false,
+      error: e.message,
+    }
+  }
+}
+
+export function validateValue(schema: any, value: string): ZodValidation {
+  const evaluatedValue = evalExp(value)
+  if (!evaluatedValue.success)
+    return evaluatedValue
+
+  try {
+    const validationRes = schema.safeParse(evaluatedValue.data)
+
+    return validationRes.success
+      ? {success: true, data: validationRes.data}
+      : {
+          success: false,
+          error: generateErrorMessage(validationRes.error.issues),
+        }
+  } catch (e) {
+    return {
+      success: false,
+      error: 'Cannot validate value. Please check the schema',
+    }
+  }
+}
+
+function evalExp(expression: string): ZodValidation {
+  try {
+    const evaluatedExpression = new Function(`return ${expression}`)()
+    return {
+      success: true,
+      data: evaluatedExpression,
+    }
+  } catch (e: any) {
+    return {
+      success: false,
+      error: e.message,
+    }
+  }
+}
+
+function generateErrorMessage(issues: any[]) {
+  const messages = []
+  for (const issue of issues)
+    messages.push(`${issue.path}: ${issue.code} - ${issue.message}`)
+
+  return messages.join(' | ')
+}
\ No newline at end of file
diff --git a/vite.config.ts b/vite.config.ts
index 7a44b51..9152196 100644
--- a/vite.config.ts
+++ b/vite.config.ts
@@ -4,4 +4,7 @@ import react from '@vitejs/plugin-react'
 // https://vitejs.dev/config/
 export default defineConfig({
   plugins: [react()],
+  build: {
+    target: 'es2022',
+  }
 })