diff --git a/drizzle-kit/src/serializer/pgSerializer.ts b/drizzle-kit/src/serializer/pgSerializer.ts
index 4ab37a0ae..6470cf1ff 100644
--- a/drizzle-kit/src/serializer/pgSerializer.ts
+++ b/drizzle-kit/src/serializer/pgSerializer.ts
@@ -30,7 +30,7 @@ import type {
 	Table,
 	UniqueConstraint,
 } from '../serializer/pgSchema';
-import type { DB } from '../utils';
+import { type DB, isPgArrayType } from '../utils';
 import { sqlToStr } from '.';
 
 const dialect = new PgDialect();
@@ -75,6 +75,43 @@ function stringFromDatabaseIdentityProperty(field: any): string | undefined {
 		: String(field);
 }
 
+function buildArrayString(array: any[], sqlType: string): string {
+	sqlType = sqlType.split('[')[0];
+	const values = array
+		.map((value) => {
+			if (typeof value === 'number' || typeof value === 'bigint') {
+				return value.toString();
+			} else if (typeof value === 'boolean') {
+				return value ? 'true' : 'false';
+			} else if (Array.isArray(value)) {
+				return buildArrayString(value, sqlType);
+			} else if (value instanceof Date) {
+				if (sqlType === 'date') {
+					return `"${value.toISOString().split('T')[0]}"`;
+				} else if (sqlType === 'timestamp') {
+					return `"${
+						value.toISOString()
+							.replace('T', ' ')
+							.slice(0, 23)
+					}"`;
+				} else {
+					return `"${value.toISOString()}"`;
+				}
+			} else if (typeof value === 'object') {
+				return `"${
+					JSON
+						.stringify(value)
+						.replaceAll('"', '\\"')
+				}"`;
+			}
+
+			return `"${value}"`;
+		})
+		.join(',');
+
+	return `{${values}}`;
+}
+
 export const generatePgSnapshot = (
 	tables: AnyPgTable[],
 	enums: PgEnum<any>[],
@@ -226,6 +263,13 @@ export const generatePgSnapshot = (
 							} else {
 								columnToSet.default = `'${column.default.toISOString()}'`;
 							}
+						} else if (isPgArrayType(sqlTypeLowered) && Array.isArray(column.default)) {
+							columnToSet.default = `'${
+								buildArrayString(
+									column.default,
+									sqlTypeLowered,
+								)
+							}'::${sqlTypeLowered}`;
 						} else {
 							// Should do for all types
 							// columnToSet.default = `'${column.default}'::${sqlTypeLowered}`;
diff --git a/drizzle-kit/src/utils.ts b/drizzle-kit/src/utils.ts
index 279520ea6..6a7faff45 100644
--- a/drizzle-kit/src/utils.ts
+++ b/drizzle-kit/src/utils.ts
@@ -327,3 +327,7 @@ export const normaliseSQLiteUrl = (
 
 	assertUnreachable(type);
 };
+
+export function isPgArrayType(sqlType: string) {
+	return sqlType.match(/.*\[\d*\].*|.*\[\].*/g) !== null;
+}
diff --git a/drizzle-kit/tests/pg-array.test.ts b/drizzle-kit/tests/pg-array.test.ts
new file mode 100644
index 000000000..a35411adb
--- /dev/null
+++ b/drizzle-kit/tests/pg-array.test.ts
@@ -0,0 +1,368 @@
+import {
+	bigint,
+	boolean,
+	date,
+	integer,
+	json,
+	pgEnum,
+	pgTable,
+	serial,
+	text,
+	timestamp,
+	uuid,
+} from 'drizzle-orm/pg-core';
+import { expect, test } from 'vitest';
+import { diffTestSchemas } from './schemaDiffer';
+
+test('array #1: empty array default', async (t) => {
+	const from = {
+		test: pgTable('test', {
+			id: serial('id').primaryKey(),
+		}),
+	};
+	const to = {
+		test: pgTable('test', {
+			id: serial('id').primaryKey(),
+			values: integer('values').array().default([]),
+		}),
+	};
+
+	const { statements } = await diffTestSchemas(from, to, []);
+
+	expect(statements.length).toBe(1);
+	expect(statements[0]).toStrictEqual({
+		type: 'alter_table_add_column',
+		tableName: 'test',
+		schema: '',
+		column: { name: 'values', type: 'integer[]', primaryKey: false, notNull: false, default: "'{}'::integer[]" },
+	});
+});
+
+test('array #2: integer array default', async (t) => {
+	const from = {
+		test: pgTable('test', {
+			id: serial('id').primaryKey(),
+		}),
+	};
+	const to = {
+		test: pgTable('test', {
+			id: serial('id').primaryKey(),
+			values: integer('values').array().default([1, 2, 3]),
+		}),
+	};
+
+	const { statements } = await diffTestSchemas(from, to, []);
+
+	expect(statements.length).toBe(1);
+	expect(statements[0]).toStrictEqual({
+		type: 'alter_table_add_column',
+		tableName: 'test',
+		schema: '',
+		column: { name: 'values', type: 'integer[]', primaryKey: false, notNull: false, default: "'{1,2,3}'::integer[]" },
+	});
+});
+
+test('array #3: bigint array default', async (t) => {
+	const from = {
+		test: pgTable('test', {
+			id: serial('id').primaryKey(),
+		}),
+	};
+	const to = {
+		test: pgTable('test', {
+			id: serial('id').primaryKey(),
+			values: bigint('values', { mode: 'bigint' }).array().default([BigInt(1), BigInt(2), BigInt(3)]),
+		}),
+	};
+
+	const { statements } = await diffTestSchemas(from, to, []);
+
+	expect(statements.length).toBe(1);
+	expect(statements[0]).toStrictEqual({
+		type: 'alter_table_add_column',
+		tableName: 'test',
+		schema: '',
+		column: { name: 'values', type: 'bigint[]', primaryKey: false, notNull: false, default: "'{1,2,3}'::bigint[]" },
+	});
+});
+
+test('array #4: boolean array default', async (t) => {
+	const from = {
+		test: pgTable('test', {
+			id: serial('id').primaryKey(),
+		}),
+	};
+	const to = {
+		test: pgTable('test', {
+			id: serial('id').primaryKey(),
+			values: boolean('values').array().default([true, false, true]),
+		}),
+	};
+
+	const { statements } = await diffTestSchemas(from, to, []);
+
+	expect(statements.length).toBe(1);
+	expect(statements[0]).toStrictEqual({
+		type: 'alter_table_add_column',
+		tableName: 'test',
+		schema: '',
+		column: {
+			name: 'values',
+			type: 'boolean[]',
+			primaryKey: false,
+			notNull: false,
+			default: "'{true,false,true}'::boolean[]",
+		},
+	});
+});
+
+test('array #5: multi-dimensional array default', async (t) => {
+	const from = {
+		test: pgTable('test', {
+			id: serial('id').primaryKey(),
+		}),
+	};
+	const to = {
+		test: pgTable('test', {
+			id: serial('id').primaryKey(),
+			values: integer('values').array().array().default([[1, 2], [3, 4]]),
+		}),
+	};
+
+	const { statements } = await diffTestSchemas(from, to, []);
+
+	expect(statements.length).toBe(1);
+	expect(statements[0]).toStrictEqual({
+		type: 'alter_table_add_column',
+		tableName: 'test',
+		schema: '',
+		column: {
+			name: 'values',
+			type: 'integer[][]',
+			primaryKey: false,
+			notNull: false,
+			default: "'{{1,2},{3,4}}'::integer[][]",
+		},
+	});
+});
+
+test('array #6: date array default', async (t) => {
+	const from = {
+		test: pgTable('test', {
+			id: serial('id').primaryKey(),
+		}),
+	};
+	const to = {
+		test: pgTable('test', {
+			id: serial('id').primaryKey(),
+			values: date('values').array().default(['2024-08-06', '2024-08-07']),
+		}),
+	};
+
+	const { statements } = await diffTestSchemas(from, to, []);
+
+	expect(statements.length).toBe(1);
+	expect(statements[0]).toStrictEqual({
+		type: 'alter_table_add_column',
+		tableName: 'test',
+		schema: '',
+		column: {
+			name: 'values',
+			type: 'date[]',
+			primaryKey: false,
+			notNull: false,
+			default: '\'{"2024-08-06","2024-08-07"}\'::date[]',
+		},
+	});
+});
+
+test('array #7: timestamp array default', async (t) => {
+	const from = {
+		test: pgTable('test', {
+			id: serial('id').primaryKey(),
+		}),
+	};
+	const to = {
+		test: pgTable('test', {
+			id: serial('id').primaryKey(),
+			values: timestamp('values').array().default([new Date('2024-08-06'), new Date('2024-08-07')]),
+		}),
+	};
+
+	const { statements } = await diffTestSchemas(from, to, []);
+
+	expect(statements.length).toBe(1);
+	expect(statements[0]).toStrictEqual({
+		type: 'alter_table_add_column',
+		tableName: 'test',
+		schema: '',
+		column: {
+			name: 'values',
+			type: 'timestamp[]',
+			primaryKey: false,
+			notNull: false,
+			default: '\'{"2024-08-06 00:00:00.000","2024-08-07 00:00:00.000"}\'::timestamp[]',
+		},
+	});
+});
+
+test('array #8: json array default', async (t) => {
+	const from = {
+		test: pgTable('test', {
+			id: serial('id').primaryKey(),
+		}),
+	};
+	const to = {
+		test: pgTable('test', {
+			id: serial('id').primaryKey(),
+			values: json('values').array().default([{ a: 1 }, { b: 2 }]),
+		}),
+	};
+
+	const { statements } = await diffTestSchemas(from, to, []);
+
+	expect(statements.length).toBe(1);
+	expect(statements[0]).toStrictEqual({
+		type: 'alter_table_add_column',
+		tableName: 'test',
+		schema: '',
+		column: {
+			name: 'values',
+			type: 'json[]',
+			primaryKey: false,
+			notNull: false,
+			default: '\'{"{\\"a\\":1}","{\\"b\\":2}"}\'::json[]',
+		},
+	});
+});
+
+test('array #9: text array default', async (t) => {
+	const from = {
+		test: pgTable('test', {
+			id: serial('id').primaryKey(),
+		}),
+	};
+	const to = {
+		test: pgTable('test', {
+			id: serial('id').primaryKey(),
+			values: text('values').array().default(['abc', 'def']),
+		}),
+	};
+
+	const { statements } = await diffTestSchemas(from, to, []);
+
+	expect(statements.length).toBe(1);
+	expect(statements[0]).toStrictEqual({
+		type: 'alter_table_add_column',
+		tableName: 'test',
+		schema: '',
+		column: {
+			name: 'values',
+			type: 'text[]',
+			primaryKey: false,
+			notNull: false,
+			default: '\'{"abc","def"}\'::text[]',
+		},
+	});
+});
+
+test('array #10: uuid array default', async (t) => {
+	const from = {
+		test: pgTable('test', {
+			id: serial('id').primaryKey(),
+		}),
+	};
+	const to = {
+		test: pgTable('test', {
+			id: serial('id').primaryKey(),
+			values: uuid('values').array().default([
+				'a0eebc99-9c0b-4ef8-bb6d-6bb9bd380a11',
+				'b0eebc99-9c0b-4ef8-bb6d-cbb9bd380a11',
+			]),
+		}),
+	};
+
+	const { statements } = await diffTestSchemas(from, to, []);
+
+	expect(statements.length).toBe(1);
+	expect(statements[0]).toStrictEqual({
+		type: 'alter_table_add_column',
+		tableName: 'test',
+		schema: '',
+		column: {
+			name: 'values',
+			type: 'uuid[]',
+			primaryKey: false,
+			notNull: false,
+			default: '\'{"a0eebc99-9c0b-4ef8-bb6d-6bb9bd380a11","b0eebc99-9c0b-4ef8-bb6d-cbb9bd380a11"}\'::uuid[]',
+		},
+	});
+});
+
+test('array #11: enum array default', async (t) => {
+	const testEnum = pgEnum('test_enum', ['a', 'b', 'c']);
+
+	const from = {
+		enum: testEnum,
+		test: pgTable('test', {
+			id: serial('id').primaryKey(),
+		}),
+	};
+	const to = {
+		enum: testEnum,
+		test: pgTable('test', {
+			id: serial('id').primaryKey(),
+			values: testEnum('values').array().default(['a', 'b', 'c']),
+		}),
+	};
+
+	const { statements } = await diffTestSchemas(from, to, []);
+
+	expect(statements.length).toBe(1);
+	expect(statements[0]).toStrictEqual({
+		type: 'alter_table_add_column',
+		tableName: 'test',
+		schema: '',
+		column: {
+			name: 'values',
+			type: 'test_enum[]',
+			primaryKey: false,
+			notNull: false,
+			default: '\'{"a","b","c"}\'::test_enum[]',
+		},
+	});
+});
+
+test('array #12: enum empty array default', async (t) => {
+	const testEnum = pgEnum('test_enum', ['a', 'b', 'c']);
+
+	const from = {
+		enum: testEnum,
+		test: pgTable('test', {
+			id: serial('id').primaryKey(),
+		}),
+	};
+	const to = {
+		enum: testEnum,
+		test: pgTable('test', {
+			id: serial('id').primaryKey(),
+			values: testEnum('values').array().default([]),
+		}),
+	};
+
+	const { statements } = await diffTestSchemas(from, to, []);
+
+	expect(statements.length).toBe(1);
+	expect(statements[0]).toStrictEqual({
+		type: 'alter_table_add_column',
+		tableName: 'test',
+		schema: '',
+		column: {
+			name: 'values',
+			type: 'test_enum[]',
+			primaryKey: false,
+			notNull: false,
+			default: "'{}'::test_enum[]",
+		},
+	});
+});
diff --git a/drizzle-kit/tests/push/pg.test.ts b/drizzle-kit/tests/push/pg.test.ts
index 1439d864e..cd5908bad 100644
--- a/drizzle-kit/tests/push/pg.test.ts
+++ b/drizzle-kit/tests/push/pg.test.ts
@@ -2162,3 +2162,77 @@ test('add identity to column - few params', async () => {
 	//   await client.query(st);
 	// }
 });
+
+test('add array column - empty array default', async () => {
+	const client = new PGlite();
+
+	const schema1 = {
+		test: pgTable('test', {
+			id: serial('id').primaryKey(),
+		}),
+	};
+	const schema2 = {
+		test: pgTable('test', {
+			id: serial('id').primaryKey(),
+			values: integer('values').array().default([]),
+		}),
+	};
+
+	const { statements, sqlStatements } = await diffTestSchemasPush(
+		client,
+		schema1,
+		schema2,
+		[],
+		false,
+		['public'],
+	);
+
+	expect(statements).toStrictEqual([
+		{
+			type: 'alter_table_add_column',
+			tableName: 'test',
+			schema: '',
+			column: { name: 'values', type: 'integer[]', primaryKey: false, notNull: false, default: "'{}'::integer[]" },
+		},
+	]);
+	expect(sqlStatements).toStrictEqual([
+		'ALTER TABLE "test" ADD COLUMN "values" integer[] DEFAULT \'{}\'::integer[];',
+	]);
+});
+
+test('add array column - default', async () => {
+	const client = new PGlite();
+
+	const schema1 = {
+		test: pgTable('test', {
+			id: serial('id').primaryKey(),
+		}),
+	};
+	const schema2 = {
+		test: pgTable('test', {
+			id: serial('id').primaryKey(),
+			values: integer('values').array().default([1, 2, 3]),
+		}),
+	};
+
+	const { statements, sqlStatements } = await diffTestSchemasPush(
+		client,
+		schema1,
+		schema2,
+		[],
+		false,
+		['public'],
+	);
+
+	expect(statements).toStrictEqual([
+		{
+			type: 'alter_table_add_column',
+			tableName: 'test',
+			schema: '',
+			column: { name: 'values', type: 'integer[]', primaryKey: false, notNull: false, default: "'{1,2,3}'::integer[]" },
+		},
+	]);
+	expect(sqlStatements).toStrictEqual([
+		'ALTER TABLE "test" ADD COLUMN "values" integer[] DEFAULT \'{1,2,3}\'::integer[];',
+	]);
+});