diff --git a/src/common/schema-derived-types.ts b/src/common/schema-derived-types.ts
index 0916bc9..00e7bc5 100644
--- a/src/common/schema-derived-types.ts
+++ b/src/common/schema-derived-types.ts
@@ -2,6 +2,7 @@ import { FromSchema, JSONSchema } from "json-schema-to-ts"
 import {
   AnyOfControlOptions,
   ArrayControlOptions,
+  EnumControlOptions,
   NumericControlOptions,
   OneOfControlOptions,
   TextControlOptions,
@@ -18,25 +19,28 @@ type RecursivePartial<T> = T extends object
 type JsonSchemaTypeToControlOptions<
   T,
   // K extends keyof T & string,
-> = T extends { type: infer U }
-  ? U extends "object" // ObjectControlOptions goes here
-    ? unknown
-    : U extends "string"
-      ? TextControlOptions
-      : U extends "number" | "integer"
-        ? NumericControlOptions
-        : U extends "array"
-          ? ArrayControlOptions
-          : U extends "boolean"
-            ? unknown // BooleanControlOptions goes here
-            : unknown
-  : T extends { anyOf: unknown }
-    ? AnyOfControlOptions
-    : T extends { oneOf: unknown }
-      ? OneOfControlOptions
-      : unknown
+> = T extends { enum: unknown }
+  ? EnumControlOptions
+  : T extends { type: infer U }
+    ? U extends "object" // ObjectControlOptions goes here
+      ? unknown
+      : U extends "string"
+        ? TextControlOptions
+        : U extends "number" | "integer"
+          ? NumericControlOptions
+          : U extends "array"
+            ? ArrayControlOptions
+            : U extends "boolean"
+              ? unknown // BooleanControlOptions goes here
+              : unknown
+    : T extends { anyOf: unknown }
+      ? AnyOfControlOptions
+      : T extends { oneOf: unknown }
+        ? OneOfControlOptions
+        : unknown
 
 type IsControlProperty<T> = T extends  // is this a property we can apply a control to?
+  | { enum: unknown }
   | { type: string }
   | { anyOf: unknown }
   | { oneOf: unknown }
diff --git a/src/controls/EnumControl.test.tsx b/src/controls/EnumControl.test.tsx
new file mode 100644
index 0000000..b254d1f
--- /dev/null
+++ b/src/controls/EnumControl.test.tsx
@@ -0,0 +1,75 @@
+import { test, expect, vi } from "vitest"
+import { screen, waitFor } from "@testing-library/react"
+import { userEvent } from "@testing-library/user-event"
+import { render } from "../common/test-render"
+import {
+  enumPSISchema,
+  enumPSIUISchema,
+  enumProfessionSchema,
+  enumProfessionUISchema,
+  enumSnakeCaseSchema,
+  enumSnakeCaseUISchema,
+} from "../testSchemas/enumSchema"
+
+test("renders the enum component as radio optionType", () => {
+  render({
+    schema: enumPSISchema,
+    uischema: enumPSIUISchema,
+  })
+
+  const radioButtons = screen.getAllByRole("radio")
+  expect(radioButtons).toHaveLength(3)
+})
+
+test("renders the enum component as dropdown optionType", () => {
+  render({
+    schema: enumProfessionSchema,
+    uischema: enumProfessionUISchema,
+  })
+
+  screen.getByRole("combobox")
+})
+
+test("renders the enum component with custom titles", async () => {
+  render({
+    schema: enumSnakeCaseSchema,
+    uischema: enumSnakeCaseUISchema,
+  })
+
+  await userEvent.click(screen.getByRole("combobox"))
+  screen.getByTitle("Option 1")
+  screen.getByTitle("Option 2")
+  screen.getByTitle("Option 3")
+})
+
+test("handles onChange event correctly", async () => {
+  const updateData = vi.fn()
+  render({
+    schema: enumProfessionSchema,
+    data: { profession: "Bob Ross Impersonator" },
+    onChange: (result) => {
+      updateData(result)
+    },
+  })
+
+  screen.getByTitle("Bob Ross Impersonator")
+  const combobox = screen.getByRole("combobox")
+
+  await userEvent.click(combobox)
+  await userEvent.click(screen.getByTitle("Footballer"))
+  await waitFor(() =>
+    expect(updateData).toHaveBeenLastCalledWith({
+      data: { profession: "Footballer" },
+      errors: [],
+    }),
+  )
+
+  await userEvent.click(combobox)
+  await userEvent.click(screen.getByTitle("Software Engineer"))
+  await waitFor(() =>
+    expect(updateData).toHaveBeenLastCalledWith({
+      data: { profession: "Software Engineer" },
+      errors: [],
+    }),
+  )
+})
diff --git a/src/controls/EnumControl.tsx b/src/controls/EnumControl.tsx
new file mode 100644
index 0000000..c98db46
--- /dev/null
+++ b/src/controls/EnumControl.tsx
@@ -0,0 +1,105 @@
+import type { ControlProps as JSFControlProps } from "@jsonforms/core"
+import { Col, Form, Select, Segmented, Radio } from "antd"
+import type { Rule } from "antd/es/form"
+import { EnumControlOptions, ControlUISchema } from "../ui-schema"
+import { withJsonFormsControlProps } from "@jsonforms/react"
+
+type ControlProps = Omit<JSFControlProps, "uischema"> & {
+  uischema: ControlUISchema<unknown> | JSFControlProps["uischema"]
+}
+
+const isStringOrNumberArray = (arr: unknown[]): boolean => {
+  return arr.every(
+    (value) => typeof value === "string" || typeof value === "number",
+  )
+}
+
+export const EnumControl = (props: ControlProps) => {
+  if (!props.visible) return null
+
+  const rules: Rule[] = [
+    { required: props.required, message: `${props.label} is required` },
+  ]
+
+  const formItemProps =
+    "formItemProps" in props.uischema ? props.uischema.formItemProps : {}
+
+  const defaultValue =
+    (props.data as unknown) ?? (props.schema.default as unknown)
+
+  const appliedUiSchemaOptions = props.uischema.options as EnumControlOptions
+
+  const enumValue = props.schema.enum
+  const enumValueToLabelMap = appliedUiSchemaOptions?.enumValueToLabelMap
+  const options =
+    enumValue && isStringOrNumberArray(enumValue)
+      ? enumValue.map((value: string | number) => ({
+          label: enumValueToLabelMap ? enumValueToLabelMap[value] : value,
+          value: value,
+        }))
+      : []
+
+  let selector
+  switch (appliedUiSchemaOptions?.optionType) {
+    case "radio":
+      selector = (
+        <Radio.Group
+          defaultValue={defaultValue}
+          options={options}
+          onChange={(e) => {
+            props.handleChange(props.path, e.target.value)
+          }}
+          optionType="button"
+          buttonStyle="solid"
+        />
+      )
+      break
+    case "segmented":
+      selector = (
+        <Segmented
+          defaultValue={defaultValue}
+          options={options}
+          onChange={(value) => {
+            props.handleChange(props.path, value)
+          }}
+        />
+      )
+      break
+    case "dropdown":
+    default:
+      selector = (
+        <Select
+          showSearch
+          defaultValue={defaultValue}
+          options={options}
+          onChange={(option) => {
+            props.handleChange(props.path, option)
+          }}
+          filterOption={(inputValue, option) => {
+            const optionValue = option?.value?.toString() || ""
+            return (
+              optionValue.toUpperCase().indexOf(inputValue.toUpperCase()) !== -1
+            )
+          }}
+        />
+      )
+      break
+  }
+
+  return (
+    <Form.Item
+      label={props.label}
+      id={props.id}
+      name={props.path}
+      required={props.required}
+      initialValue={defaultValue}
+      rules={rules}
+      validateTrigger={["onBlur"]}
+      {...formItemProps}
+    >
+      <Col span={18}>{selector}</Col>
+    </Form.Item>
+  )
+}
+
+export const EnumRenderer = withJsonFormsControlProps(EnumControl)
diff --git a/src/controls/combinators/AnyOfControl.test.tsx b/src/controls/combinators/AnyOfControl.test.tsx
index 96285e4..2e87371 100644
--- a/src/controls/combinators/AnyOfControl.test.tsx
+++ b/src/controls/combinators/AnyOfControl.test.tsx
@@ -37,17 +37,16 @@ describe("AnyOf control", () => {
     // Column Name is available in both subschemas
     await screen.findByText("Splitter")
     screen.getByLabelText("Column Name")
-    expect(screen.queryByLabelText("Method Name")).toHaveValue("split_on_year")
+    screen.getByTitle("split_on_year")
+    expect(
+      screen.queryByTitle("split_on_year_and_month"),
+    ).not.toBeInTheDocument()
 
     // UiSchema is not set here, so we should see the Method Name changing
 
     await userEvent.click(screen.getByLabelText("SplitterYearAndMonth"))
     screen.getByLabelText("Column Name")
-    await waitFor(() =>
-      expect(screen.queryByLabelText("Method Name")).toHaveValue(
-        "split_on_year_and_month",
-      ),
-    )
+    screen.getByTitle("split_on_year_and_month")
   })
   test("AnyOf Control with button UISchema allows switching between subschemas and respects uiSchemaRegistryEntries", async () => {
     render({
@@ -77,7 +76,10 @@ describe("AnyOf control", () => {
     // Column Name is available in both subschemas
     await screen.findByText("Splitter")
     screen.getByLabelText("Column Name")
-    expect(screen.queryByLabelText("Method Name")).toHaveValue("split_on_year")
+    screen.getByTitle("split_on_year")
+    expect(
+      screen.queryByTitle("split_on_year_and_month"),
+    ).not.toBeInTheDocument()
 
     // Open the dropdown
     await userEvent.click(screen.getByText("Year"))
@@ -85,9 +87,7 @@ describe("AnyOf control", () => {
     // Select another option
     await userEvent.click(screen.getByText("Year - Month"))
     screen.getByLabelText("Column Name")
-    expect(screen.queryByLabelText("Method Name")).toHaveValue(
-      "split_on_year_and_month",
-    )
+    screen.getByTitle("split_on_year_and_month")
   })
   test("AnyOf Control persists state when switching between subschemas", async () => {
     render({ schema: splitterAnyOfJsonSchema })
@@ -98,13 +98,13 @@ describe("AnyOf control", () => {
     await userEvent.type(screen.getByLabelText("Column Name"), "abc")
 
     await userEvent.click(screen.getByLabelText("SplitterYearAndMonth"))
-    screen.getByLabelText("Column Name")
-    expect(screen.queryByLabelText("Column Name")).not.toHaveValue("abc")
+    let column = screen.getByLabelText("Column Name")
+    expect(column).not.toHaveValue("abc")
     await userEvent.type(screen.getByLabelText("Column Name"), "xyz")
 
     await userEvent.click(screen.getByLabelText("SplitterYear"))
-    screen.getByLabelText("Column Name")
-    expect(screen.queryByLabelText("Column Name")).toHaveValue("abc")
+    column = screen.getByLabelText("Column Name")
+    expect(column).toHaveValue("abc")
   })
   test("provides a default value for a required combinator", async () => {
     let data: JSONFormData<typeof AnyOfWithDefaultsSchema> = {}
diff --git a/src/renderer-registry-entries.ts b/src/renderer-registry-entries.ts
index c0b6aaf..9e93be6 100644
--- a/src/renderer-registry-entries.ts
+++ b/src/renderer-registry-entries.ts
@@ -20,6 +20,7 @@ import {
   isPrimitiveArrayControl,
   isOneOfControl,
   isAnyOfControl,
+  isEnumControl,
 } from "@jsonforms/core"
 import { withJsonFormsCellProps } from "@jsonforms/react"
 
@@ -37,6 +38,7 @@ import { ObjectArrayRenderer } from "./controls/ObjectArrayControl"
 import { PrimitiveArrayRenderer } from "./controls/PrimitiveArrayControl"
 import { OneOfRenderer } from "./controls/combinators/OneOfControl"
 import { AnyOfRenderer } from "./controls/combinators/AnyOfControl"
+import { EnumRenderer } from "./controls/EnumControl"
 
 // Ordered from lowest rank to highest rank. Higher rank renderers will be preferred over lower rank renderers.
 export const rendererRegistryEntries: JsonFormsRendererRegistryEntry[] = [
@@ -85,16 +87,20 @@ export const rendererRegistryEntries: JsonFormsRendererRegistryEntry[] = [
     renderer: NumericSliderRenderer,
   },
   {
-    tester: rankWith(3, isOneOfControl),
+    tester: rankWith(4, isEnumControl),
+    renderer: EnumRenderer,
+  },
+  {
+    tester: rankWith(5, isOneOfControl),
     renderer: OneOfRenderer,
   },
   {
-    tester: rankWith(3, isAnyOfControl),
+    tester: rankWith(5, isAnyOfControl),
     renderer: AnyOfRenderer,
   },
   {
     tester: rankWith(
-      3,
+      5,
       or(isObjectArrayControl, isObjectArray, isObjectArrayWithNesting),
     ),
     renderer: ObjectArrayRenderer,
diff --git a/src/stories/controls/EnumControl.stories.tsx b/src/stories/controls/EnumControl.stories.tsx
new file mode 100644
index 0000000..77f74c8
--- /dev/null
+++ b/src/stories/controls/EnumControl.stories.tsx
@@ -0,0 +1,62 @@
+import { Meta, StoryObj } from "@storybook/react"
+import { StorybookAntDJsonForm } from "../../common/StorybookAntDJsonForm"
+import {
+  enumPSISchema,
+  enumPSIUISchema,
+  enumProfessionSchema,
+  enumProfessionUISchema,
+  enumSizeSchema,
+  enumSizeUISchema,
+  enumSnakeCaseSchema,
+  enumSnakeCaseUISchema,
+} from "../../testSchemas/enumSchema"
+
+const meta: Meta<typeof StorybookAntDJsonForm> = {
+  title: "Control/Enum",
+  component: StorybookAntDJsonForm,
+  tags: ["autodocs"],
+  args: {
+    jsonSchema: enumProfessionSchema,
+    uiSchema: enumProfessionUISchema,
+  },
+  argTypes: {
+    uiSchema: {
+      control: "object",
+    },
+  },
+}
+
+export default meta
+type Story = StoryObj<typeof StorybookAntDJsonForm>
+
+export const RequiredDropdown: Story = {
+  tags: ["autodocs"],
+  args: {
+    jsonSchema: enumProfessionSchema,
+    uiSchema: enumProfessionUISchema,
+  },
+}
+
+export const SegmentedWithDefault: Story = {
+  tags: ["autodocs"],
+  args: {
+    jsonSchema: enumSizeSchema,
+    uiSchema: enumSizeUISchema,
+  },
+}
+
+export const Radio: Story = {
+  tags: ["autodocs"],
+  args: {
+    jsonSchema: enumPSISchema,
+    uiSchema: enumPSIUISchema,
+  },
+}
+
+export const CustomLabels: Story = {
+  tags: ["autodocs"],
+  args: {
+    jsonSchema: enumSnakeCaseSchema,
+    uiSchema: enumSnakeCaseUISchema,
+  },
+}
diff --git a/src/testSchemas/enumSchema.ts b/src/testSchemas/enumSchema.ts
new file mode 100644
index 0000000..fb094ce
--- /dev/null
+++ b/src/testSchemas/enumSchema.ts
@@ -0,0 +1,105 @@
+import { JSONSchema } from "json-schema-to-ts"
+import { UISchema } from "../ui-schema"
+
+export const enumSizeSchema = {
+  type: "object",
+  properties: {
+    size: {
+      title: "Size",
+      type: "string",
+      enum: ["XS", "S", "M", "L", "XL"],
+      default: "M",
+    },
+  },
+  required: ["size"],
+} satisfies JSONSchema
+
+export const enumProfessionSchema = {
+  type: "object",
+  properties: {
+    profession: {
+      title: "Profession",
+      type: "string",
+      enum: [
+        "Footballer",
+        "Bob Ross Impersonator",
+        "Beat Boxer",
+        "Software Engineer",
+      ],
+    },
+  },
+  required: ["profession"],
+} satisfies JSONSchema
+
+export const enumPSISchema = {
+  type: "object",
+  properties: {
+    psi: {
+      title: "Approximate PSI",
+      type: "integer",
+      enum: [100, 1000, 10000],
+    },
+  },
+} satisfies JSONSchema
+
+export const enumSnakeCaseSchema = {
+  type: "object",
+  properties: {
+    humanReadableOptions: {
+      title: "Human Readable Options",
+      type: "string",
+      enum: ["option_1", "option_2", "option_3"],
+    },
+  },
+} satisfies JSONSchema
+
+export const enumSizeUISchema = {
+  type: "VerticalLayout",
+  elements: [
+    {
+      type: "Control",
+      scope: "#/properties/size",
+      options: { optionType: "segmented" },
+    },
+  ],
+} satisfies UISchema<typeof enumSizeSchema>
+
+export const enumProfessionUISchema = {
+  type: "VerticalLayout",
+  elements: [
+    {
+      type: "Control",
+      scope: "#/properties/profession",
+      options: { optionType: "dropdown" },
+    },
+  ],
+} satisfies UISchema<typeof enumProfessionSchema>
+
+export const enumPSIUISchema = {
+  type: "VerticalLayout",
+  elements: [
+    {
+      type: "Control",
+      scope: "#/properties/psi",
+      options: { optionType: "radio" },
+    },
+  ],
+} satisfies UISchema<typeof enumPSISchema>
+
+export const enumSnakeCaseUISchema = {
+  type: "VerticalLayout",
+  elements: [
+    {
+      type: "Control",
+      scope: "#/properties/humanReadableOptions",
+      options: {
+        optionType: "dropdown",
+        enumValueToLabelMap: {
+          option_1: "Option 1",
+          option_2: "Option 2",
+          option_3: "Option 3",
+        },
+      },
+    },
+  ],
+} satisfies UISchema<typeof enumSnakeCaseSchema>
diff --git a/src/ui-schema.ts b/src/ui-schema.ts
index 4b6f997..a370dce 100644
--- a/src/ui-schema.ts
+++ b/src/ui-schema.ts
@@ -152,6 +152,15 @@ export type OneOfControlOptions = {
 
 export type AnyOfControlOptions = OneOfControlOptions
 
+export const EnumOptions = ["dropdown", "radio", "segmented"] as const
+
+export type EnumOption = (typeof EnumOptions)[number]
+
+export type EnumControlOptions = {
+  optionType?: EnumOption
+  enumValueToLabelMap?: Record<string | number, string>
+}
+
 export type TextControlType = "multiline" | "password" | "singleline"
 
 export type TextControlOptions = {