diff --git a/app/pages/org/[org].vue b/app/pages/org/[org].vue
index 47c2fa2fc9..a7082c8296 100644
--- a/app/pages/org/[org].vue
+++ b/app/pages/org/[org].vue
@@ -1,5 +1,18 @@
 <script setup lang="ts">
-import type { FilterChip, SortOption } from '#shared/types/preferences'
+import {
+  type ColumnConfig,
+  type FilterChip,
+  type SortOption,
+  type StructuredFilters,
+  DEFAULT_COLUMNS,
+  DEFAULT_FILTERS,
+  parseDownloadRange,
+  parseSearchScope,
+  parseSecurityFilter,
+  parseUpdatedWithin,
+  parseColumns,
+  serializeVisibleColumns,
+} from '#shared/types/preferences'
 import { normalizeSearchParam } from '#shared/utils/url'
 import { debounce } from 'perfect-debounce'
 
@@ -39,9 +52,61 @@ const packages = computed(() => results.value?.objects ?? [])
 const packageCount = computed(() => packages.value.length)
 
 // Preferences (persisted to localStorage)
-const { viewMode, paginationMode, pageSize, columns, toggleColumn, resetColumns } =
+const { viewMode, paginationMode, pageSize, columns, toggleColumn, resetColumns, isHydrated } =
   usePackageListPreferences()
 
+const initialFilters: Partial<StructuredFilters> = {}
+const searchScope = parseSearchScope(normalizeSearchParam(route.query.scope))
+const downloadRange = parseDownloadRange(normalizeSearchParam(route.query.downloads))
+const security = parseSecurityFilter(normalizeSearchParam(route.query.security))
+const updatedWithin = parseUpdatedWithin(normalizeSearchParam(route.query.updated))
+
+if (searchScope) initialFilters.searchScope = searchScope
+if (downloadRange) initialFilters.downloadRange = downloadRange
+if (security) initialFilters.security = security
+if (updatedWithin) initialFilters.updatedWithin = updatedWithin
+
+const columnOverride = shallowRef<ColumnConfig[] | null>(null)
+
+watch(
+  [isHydrated, () => route.query.columns],
+  ([hydrated]) => {
+    if (!hydrated) return
+    const ids = parseColumns(
+      route.query.columns === undefined ? undefined : normalizeSearchParam(route.query.columns),
+    )
+    if (!ids) {
+      columnOverride.value = null
+      return
+    }
+    columnOverride.value = columns.value.map(col => ({
+      ...col,
+      visible: col.id === 'name' || ids.includes(col.id),
+    }))
+  },
+  { immediate: true },
+)
+
+const viewColumns = computed(() => columnOverride.value ?? columns.value)
+
+function handleToggleColumn(columnId: ColumnConfig['id']) {
+  if (!columnOverride.value) {
+    toggleColumn(columnId)
+    return
+  }
+  columnOverride.value = columnOverride.value.map(col =>
+    col.id === columnId ? { ...col, visible: !col.visible } : col,
+  )
+}
+
+function handleResetColumns() {
+  if (!columnOverride.value) {
+    resetColumns()
+    return
+  }
+  columnOverride.value = DEFAULT_COLUMNS.map(col => ({ ...col }))
+}
+
 // Structured filters and sorting
 const {
   filters,
@@ -61,6 +126,7 @@ const {
 } = useStructuredFilters({
   packages,
   initialSort: (normalizeSearchParam(route.query.sort) as SortOption) ?? DEFAULT_SORT,
+  initialFilters,
 })
 
 // Pagination state
@@ -84,24 +150,61 @@ watch(totalPages, newTotal => {
 })
 
 // Debounced URL update for filter/sort
-const updateUrl = debounce((updates: { filter?: string; sort?: string }) => {
-  router.replace({
-    query: {
-      ...route.query,
-      q: updates.filter || undefined,
-      sort: updates.sort && updates.sort !== DEFAULT_SORT ? updates.sort : undefined,
-    },
-  })
-}, 300)
-
-// Update URL when filter/sort changes (debounced)
+const updateUrl = debounce(
+  (updates: {
+    filter?: string
+    sort?: string
+    scope?: string
+    downloads?: string
+    security?: string
+    updated?: string
+  }) => {
+    router.replace({
+      query: {
+        ...route.query,
+        q: updates.filter || undefined,
+        sort: updates.sort && updates.sort !== DEFAULT_SORT ? updates.sort : undefined,
+        columns: serializeVisibleColumns(viewColumns.value),
+        scope:
+          updates.scope && updates.scope !== DEFAULT_FILTERS.searchScope
+            ? updates.scope
+            : undefined,
+        downloads:
+          updates.downloads && updates.downloads !== DEFAULT_FILTERS.downloadRange
+            ? updates.downloads
+            : undefined,
+        security:
+          updates.security && updates.security !== DEFAULT_FILTERS.security
+            ? updates.security
+            : undefined,
+        updated:
+          updates.updated && updates.updated !== DEFAULT_FILTERS.updatedWithin
+            ? updates.updated
+            : undefined,
+      },
+    })
+  },
+  300,
+)
+
+// Update URL when filter/sort/columns change (debounced)
 watch(
-  [() => filters.value.text, () => filters.value.keywords, () => sortOption.value] as const,
-  ([text, keywords, sort]) => {
+  [
+    () => filters.value.text,
+    () => filters.value.keywords,
+    () => sortOption.value,
+    () => filters.value.searchScope,
+    () => filters.value.downloadRange,
+    () => filters.value.security,
+    () => filters.value.updatedWithin,
+    // serialize so visibility toggles (same array ref) still trigger
+    () => serializeVisibleColumns(viewColumns.value),
+  ] as const,
+  ([text, keywords, sort, scope, downloads, security, updated]) => {
     const filter = [text, ...keywords.map(keyword => `keyword:${keyword}`)]
       .filter(Boolean)
       .join(' ')
-    updateUrl({ filter, sort })
+    updateUrl({ filter, sort, scope, downloads, security, updated })
   },
 )
 
@@ -298,15 +401,15 @@ defineOgImage(
         :filters="filters"
         v-model:sort-option="sortOption"
         v-model:view-mode="viewMode"
-        :columns="columns"
+        :columns="viewColumns"
         v-model:pagination-mode="paginationMode"
         v-model:page-size="pageSize"
         :total-count="packageCount"
         :filtered-count="filteredCount"
         :available-keywords="availableKeywords"
         :active-filters="activeFilters"
-        @toggle-column="toggleColumn"
-        @reset-columns="resetColumns"
+        @toggle-column="handleToggleColumn"
+        @reset-columns="handleResetColumns"
         @clear-filter="handleClearFilter"
         @clear-all-filters="clearAllFilters"
         @update:text="setTextFilter"
@@ -328,7 +431,7 @@ defineOgImage(
         <PackageList
           :results="sortedPackages"
           :view-mode="viewMode"
-          :columns="columns"
+          :columns="viewColumns"
           :filters="filters"
           v-model:sort-option="sortOption"
           :pagination-mode="paginationMode"
diff --git a/shared/types/preferences.ts b/shared/types/preferences.ts
index 886365aa41..2f2726102c 100644
--- a/shared/types/preferences.ts
+++ b/shared/types/preferences.ts
@@ -50,6 +50,38 @@ export const DEFAULT_COLUMNS: ColumnConfig[] = [
   },
 ]
 
+function visibleColumnIdsParam(columns: ColumnConfig[]): string {
+  const visible = new Set(
+    columns
+      .filter(col => col.visible && col.id !== 'selection' && col.id !== 'name')
+      .map(col => col.id),
+  )
+  return DEFAULT_COLUMNS.filter(col => visible.has(col.id))
+    .map(col => col.id)
+    .join(',')
+}
+
+/** Comma-separated visible column ids, or undefined when they match the default set. `name` is omitted (always visible). */
+export function serializeVisibleColumns(columns: ColumnConfig[]): string | undefined {
+  const visibleColumnIds = visibleColumnIdsParam(columns)
+  return visibleColumnIds === visibleColumnIdsParam(DEFAULT_COLUMNS) ? undefined : visibleColumnIds
+}
+
+function isColumnId(id: string): id is ColumnId {
+  return DEFAULT_COLUMNS.some(col => col.id === id)
+}
+
+export function parseColumns(value: string | undefined): ColumnId[] | undefined {
+  if (value === undefined) return undefined
+  if (value === '') return []
+
+  const ids = value
+    .split(',')
+    .map(id => id.trim())
+    .filter(isColumnId)
+  return ids.length > 0 ? ids : undefined
+}
+
 // Sort keys (without direction)
 export type SortKey =
   | 'downloads-week'
@@ -203,6 +235,22 @@ export type SearchScope = 'name' | 'description' | 'keywords' | 'all'
 /** Search scope values - labels are in i18n under filters.scope_* */
 export const SEARCH_SCOPE_VALUES: SearchScope[] = ['name', 'description', 'keywords', 'all']
 
+export function parseSearchScope(value: string): SearchScope | undefined {
+  return SEARCH_SCOPE_VALUES.find(scope => scope === value)
+}
+
+export function parseDownloadRange(value: string): DownloadRange | undefined {
+  return DOWNLOAD_RANGES.find(range => range.value === value)?.value
+}
+
+export function parseSecurityFilter(value: string): SecurityFilter | undefined {
+  return SECURITY_FILTER_VALUES.find(filter => filter === value)
+}
+
+export function parseUpdatedWithin(value: string): UpdatedWithin | undefined {
+  return UPDATED_WITHIN_OPTIONS.find(option => option.value === value)?.value
+}
+
 // Structured filters state
 export interface StructuredFilters {
   text: string
@@ -211,6 +259,7 @@ export interface StructuredFilters {
   keywords: string[]
   security: SecurityFilter
   updatedWithin: UpdatedWithin
+  visibleColumns: ColumnId[]
 }
 
 export const DEFAULT_FILTERS: StructuredFilters = {
@@ -220,6 +269,7 @@ export const DEFAULT_FILTERS: StructuredFilters = {
   keywords: [],
   security: 'all',
   updatedWithin: 'any',
+  visibleColumns: DEFAULT_COLUMNS.map(c => c.id),
 }
 
 // Pagination modes
diff --git a/test/nuxt/a11y.spec.ts b/test/nuxt/a11y.spec.ts
index 923d9f7df4..b37687f1c5 100644
--- a/test/nuxt/a11y.spec.ts
+++ b/test/nuxt/a11y.spec.ts
@@ -1,4 +1,4 @@
-import type { ColumnConfig, FilterChip } from '#shared/types/preferences'
+import { DEFAULT_FILTERS, type ColumnConfig, type FilterChip } from '#shared/types/preferences'
 import { mountSuspended, registerEndpoint } from '@nuxt/test-utils/runtime'
 import type { VueWrapper } from '@vue/test-utils'
 import 'axe-core'
@@ -2180,6 +2180,7 @@ describe('component accessibility audits', () => {
       updatedWithin: 'any' as const,
       security: 'all' as const,
       keywords: [],
+      visibleColumns: DEFAULT_FILTERS.visibleColumns,
     }
 
     it('should have no accessibility violations (collapsed)', async () => {
@@ -2213,6 +2214,7 @@ describe('component accessibility audits', () => {
       updatedWithin: 'any' as const,
       security: 'all' as const,
       keywords: [],
+      visibleColumns: DEFAULT_FILTERS.visibleColumns,
     }
 
     const mockColumns: ColumnConfig[] = [
diff --git a/test/unit/shared/types/preferences.spec.ts b/test/unit/shared/types/preferences.spec.ts
index 9d928c57ec..07ea7e1134 100644
--- a/test/unit/shared/types/preferences.spec.ts
+++ b/test/unit/shared/types/preferences.spec.ts
@@ -1,13 +1,30 @@
 import { describe, expect, it } from 'vitest'
 import {
   buildSortOption,
+  DEFAULT_COLUMNS,
+  parseColumns,
+  parseDownloadRange,
+  parseSearchScope,
+  parseSecurityFilter,
   parseSortOption,
+  parseUpdatedWithin,
+  serializeVisibleColumns,
   toggleDirection,
+  type ColumnConfig,
   type SortDirection,
   type SortKey,
   type SortOption,
 } from '#shared/types/preferences'
 
+function columnsWithVisibility(
+  overrides: Partial<Record<ColumnConfig['id'], boolean>>,
+): ColumnConfig[] {
+  return DEFAULT_COLUMNS.map(col => ({
+    ...col,
+    visible: overrides[col.id] ?? col.visible,
+  }))
+}
+
 describe('parseSortOption', () => {
   it.each<[SortOption, SortKey, SortDirection]>([
     ['downloads-week-desc', 'downloads-week', 'desc'],
@@ -59,6 +76,104 @@ describe('toggleDirection', () => {
   })
 })
 
+describe('parseSearchScope', () => {
+  it.each(['name', 'description', 'keywords', 'all'] as const)('accepts "%s"', value => {
+    expect(parseSearchScope(value)).toBe(value)
+  })
+
+  it.each(['', 'banana', 'NAME'])('rejects "%s"', value => {
+    expect(parseSearchScope(value)).toBeUndefined()
+  })
+})
+
+describe('parseDownloadRange', () => {
+  it.each(['any', 'lt100', '100-1k', '1k-10k', '10k-100k', 'gt100k'] as const)(
+    'accepts "%s"',
+    value => {
+      expect(parseDownloadRange(value)).toBe(value)
+    },
+  )
+
+  it.each(['', 'banana', 'gt1000'])('rejects "%s"', value => {
+    expect(parseDownloadRange(value)).toBeUndefined()
+  })
+})
+
+describe('parseSecurityFilter', () => {
+  it.each(['all', 'secure', 'warnings'] as const)('accepts "%s"', value => {
+    expect(parseSecurityFilter(value)).toBe(value)
+  })
+
+  it.each(['', 'banana', 'insecure'])('rejects "%s"', value => {
+    expect(parseSecurityFilter(value)).toBeUndefined()
+  })
+})
+
+describe('parseUpdatedWithin', () => {
+  it.each(['any', 'week', 'month', 'quarter', 'year'] as const)('accepts "%s"', value => {
+    expect(parseUpdatedWithin(value)).toBe(value)
+  })
+
+  it.each(['', 'banana', 'day'])('rejects "%s"', value => {
+    expect(parseUpdatedWithin(value)).toBeUndefined()
+  })
+})
+
+describe('parseColumns', () => {
+  it('parses comma-separated ids', () => {
+    expect(parseColumns('version,downloads')).toEqual(['version', 'downloads'])
+  })
+
+  it('trims whitespace and drops unknown ids', () => {
+    expect(parseColumns(' version , nope, downloads ')).toEqual(['version', 'downloads'])
+  })
+
+  it('keeps name if present', () => {
+    expect(parseColumns('name,version')).toEqual(['name', 'version'])
+  })
+
+  it('distinguishes an empty parameter from an absent parameter', () => {
+    expect(parseColumns('')).toEqual([])
+    expect(parseColumns(undefined)).toBeUndefined()
+  })
+
+  it.each(['banana', ' , , '])('returns undefined for invalid value "%s"', value => {
+    expect(parseColumns(value)).toBeUndefined()
+  })
+})
+
+describe('serializeVisibleColumns', () => {
+  it('omits the param for default visibilities', () => {
+    expect(serializeVisibleColumns(DEFAULT_COLUMNS)).toBeUndefined()
+  })
+
+  it('omits name and selection', () => {
+    const columns = columnsWithVisibility({ maintainers: true })
+    expect(serializeVisibleColumns(columns)).toBe(
+      'version,description,downloads,updated,maintainers',
+    )
+  })
+
+  it('includes the param when a default-on column is hidden', () => {
+    expect(serializeVisibleColumns(columnsWithVisibility({ version: false }))).toBe(
+      'description,downloads,updated',
+    )
+  })
+
+  it('roundtrips a name-only selection as an empty parameter', () => {
+    const nameOnlyColumns = columnsWithVisibility({
+      version: false,
+      description: false,
+      downloads: false,
+      updated: false,
+    })
+    const serialized = serializeVisibleColumns(nameOnlyColumns)
+
+    expect(serialized).toBe('')
+    expect(parseColumns(serialized)).toEqual([])
+  })
+})
+
 describe('parseSortOption and buildSortOption roundtrip', () => {
   it.each<SortOption>([
     'downloads-week-desc',