diff --git a/packages/@react-aria/checkbox/package.json b/packages/@react-aria/checkbox/package.json
index 7f31bff075a..1ed2cb40a64 100644
--- a/packages/@react-aria/checkbox/package.json
+++ b/packages/@react-aria/checkbox/package.json
@@ -18,7 +18,10 @@
   },
   "dependencies": {
     "@babel/runtime": "^7.6.2",
+    "@react-aria/label": "^3.1.0",
     "@react-aria/toggle": "^3.1.0",
+    "@react-aria/utils": "^3.1.0",
+    "@react-stately/checkbox": "^3.1.0",
     "@react-stately/toggle": "^3.1.0",
     "@react-types/checkbox": "^3.1.0"
   },
diff --git a/packages/@react-aria/checkbox/src/index.ts b/packages/@react-aria/checkbox/src/index.ts
index 38cda41ccc4..63e2a88c34d 100644
--- a/packages/@react-aria/checkbox/src/index.ts
+++ b/packages/@react-aria/checkbox/src/index.ts
@@ -11,3 +11,5 @@
  */
 
 export * from './useCheckbox';
+export * from './useCheckboxGroup';
+export * from './useCheckboxGroupItem';
diff --git a/packages/@react-aria/checkbox/src/useCheckboxGroup.ts b/packages/@react-aria/checkbox/src/useCheckboxGroup.ts
new file mode 100644
index 00000000000..28be095a42e
--- /dev/null
+++ b/packages/@react-aria/checkbox/src/useCheckboxGroup.ts
@@ -0,0 +1,51 @@
+/*
+ * Copyright 2020 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+
+import {AriaCheckboxGroupProps} from '@react-types/checkbox';
+import {filterDOMProps, mergeProps} from '@react-aria/utils';
+import {HTMLAttributes} from 'react';
+import {useLabel} from '@react-aria/label';
+
+interface CheckboxGroupAria {
+  /** Props for the checkbox group wrapper element. */
+  checkboxGroupProps: HTMLAttributes<HTMLElement>,
+  /** Props for the checkbox group's visible label (if any). */
+  labelProps: HTMLAttributes<HTMLElement>
+}
+
+/**
+ * Provides the behavior and accessibility implementation for a checkbox group component.
+ * Checkbox groups allow users to select multiple items from a list of options.
+ * @param props - Props for the checkbox group.
+ * @param state - State for the checkbox group, as returned by `useCheckboxGroupState`.
+ */
+export function useCheckboxGroup(props: AriaCheckboxGroupProps): CheckboxGroupAria {
+  let {isDisabled} = props;
+
+  let {labelProps, fieldProps} = useLabel({
+    ...props,
+    // Checkbox group is not an HTML input element so it
+    // shouldn't be labeled by a <label> element.
+    labelElementType: 'span'
+  });
+
+  let domProps = filterDOMProps(props, {labelable: true});
+
+  return {
+    checkboxGroupProps: mergeProps(domProps, {
+      role: 'group',
+      'aria-disabled': isDisabled || undefined,
+      ...fieldProps
+    }),
+    labelProps
+  };
+}
diff --git a/packages/@react-aria/checkbox/src/useCheckboxGroupItem.ts b/packages/@react-aria/checkbox/src/useCheckboxGroupItem.ts
new file mode 100644
index 00000000000..5a917eca608
--- /dev/null
+++ b/packages/@react-aria/checkbox/src/useCheckboxGroupItem.ts
@@ -0,0 +1,43 @@
+/*
+ * Copyright 2020 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+
+import {AriaCheckboxGroupItemProps} from '@react-types/checkbox';
+import {CheckboxAria, useCheckbox} from './useCheckbox';
+import {CheckboxGroupState} from '@react-stately/checkbox';
+import {RefObject} from 'react';
+import {useToggleState} from '@react-stately/toggle';
+
+/**
+ * Provides the behavior and accessibility implementation for a checkbox component contained within a checkbox group.
+ * Checkbox groups allow users to select multiple items from a list of options.
+ * @param props - Props for the checkbox.
+ * @param state - State for the checkbox, as returned by `useCheckboxGroupState`.
+ * @param inputRef - A ref for the HTML input element.
+ */
+export function useCheckboxGroupItem(props: AriaCheckboxGroupItemProps, state: CheckboxGroupState, inputRef: RefObject<HTMLInputElement>): CheckboxAria {
+  const toggleState = useToggleState({
+    isReadOnly: props.isReadOnly,
+    isSelected: state.value.includes(props.value),
+    onChange(isSelected) {
+      if (isSelected) {
+        state.addValue(props.value);
+      } else {
+        state.removeValue(props.value);
+      }
+
+      if (props.onChange) {
+        props.onChange(isSelected);
+      }
+    }
+  });
+  return useCheckbox({...props, name: state.name}, toggleState, inputRef);
+}
diff --git a/packages/@react-aria/checkbox/test/useCheckboxGroup.test.tsx b/packages/@react-aria/checkbox/test/useCheckboxGroup.test.tsx
new file mode 100644
index 00000000000..c1f2e477c58
--- /dev/null
+++ b/packages/@react-aria/checkbox/test/useCheckboxGroup.test.tsx
@@ -0,0 +1,229 @@
+/*
+ * Copyright 2020 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+
+import {act, render} from '@testing-library/react';
+import {AriaCheckboxGroupProps, AriaCheckboxProps} from '@react-types/checkbox';
+import {CheckboxGroupState, useCheckboxGroupState} from '@react-stately/checkbox';
+import React, {useRef} from 'react';
+import {useCheckboxGroup, useCheckboxGroupItem} from '../';
+import userEvent from '@testing-library/user-event';
+
+function Checkbox({checkboxGroupState, ...props}: AriaCheckboxProps & { checkboxGroupState: CheckboxGroupState }) {
+  const ref = useRef<HTMLInputElement>();
+  const {children} = props;
+  const {inputProps} = useCheckboxGroupItem(props, checkboxGroupState, ref);
+  return <label>{children}<input ref={ref} {...inputProps} /></label>;
+}
+
+function CheckboxGroup({groupProps, checkboxProps}: {groupProps: AriaCheckboxGroupProps, checkboxProps: AriaCheckboxProps[]}) {
+  const state = useCheckboxGroupState(groupProps);
+  const {checkboxGroupProps, labelProps} = useCheckboxGroup(groupProps);
+  return (
+    <div {...checkboxGroupProps}>
+      {groupProps.label && <span {...labelProps}>{groupProps.label}</span>}
+      <Checkbox checkboxGroupState={state} {...checkboxProps[0]} />
+      <Checkbox checkboxGroupState={state} {...checkboxProps[1]} />
+      <Checkbox checkboxGroupState={state} {...checkboxProps[2]} />
+    </div>
+  );
+}
+
+describe('useCheckboxGroup', () => {
+  it('handles defaults', () => {
+    let onChangeSpy = jest.fn();
+    let {getByRole, getAllByRole, getByLabelText} = render(
+      <CheckboxGroup
+        groupProps={{label: 'Favorite Pet', onChange: onChangeSpy}}
+        checkboxProps={[
+          {value: 'dogs', children: 'Dogs'},
+          {value: 'cats', children: 'Cats'},
+          {value: 'dragons', children: 'Dragons'}
+        ]} />
+    );
+
+    let checkboxGroup = getByRole('group', {exact: true});
+    let checkboxes = getAllByRole('checkbox') as HTMLInputElement[];
+    expect(checkboxGroup).toBeInTheDocument();
+    expect(checkboxes.length).toBe(3);
+
+    let groupName = checkboxes[0].getAttribute('name');
+    expect(checkboxes[0]).toHaveAttribute('name', groupName);
+    expect(checkboxes[1]).toHaveAttribute('name', groupName);
+    expect(checkboxes[2]).toHaveAttribute('name', groupName);
+
+    expect(checkboxes[0].value).toBe('dogs');
+    expect(checkboxes[1].value).toBe('cats');
+    expect(checkboxes[2].value).toBe('dragons');
+
+    expect(checkboxes[0].checked).toBe(false);
+    expect(checkboxes[1].checked).toBe(false);
+    expect(checkboxes[2].checked).toBe(false);
+
+    let dragons = getByLabelText('Dragons');
+    act(() => {userEvent.click(dragons);});
+    expect(onChangeSpy).toHaveBeenCalledTimes(1);
+    expect(onChangeSpy).toHaveBeenCalledWith(['dragons']);
+
+    expect(checkboxes[0].checked).toBe(false);
+    expect(checkboxes[1].checked).toBe(false);
+    expect(checkboxes[2].checked).toBe(true);
+  });
+
+  it('can have a default value', () => {
+    let {getByLabelText} = render(
+      <CheckboxGroup
+        groupProps={{label: 'Favorite Pet', value: ['cats']}}
+        checkboxProps={[
+          {value: 'dogs', children: 'Dogs'},
+          {value: 'cats', children: 'Cats'},
+          {value: 'dragons', children: 'Dragons'}
+        ]} />
+    );
+
+    expect((getByLabelText('Cats') as HTMLInputElement).checked).toBe(true);
+  });
+
+  it('name can be controlled', () => {
+    let {getAllByRole} = render(
+      <CheckboxGroup
+        groupProps={{name: 'awesome-react-aria', label: 'Favorite Pet'}}
+        checkboxProps={[
+          {value: 'dogs', children: 'Dogs'},
+          {value: 'cats', children: 'Cats'},
+          {value: 'dragons', children: 'Dragons'}
+        ]} />
+    );
+
+    let checkboxes = getAllByRole('checkbox') as HTMLInputElement[];
+
+    expect(checkboxes[0]).toHaveAttribute('name', 'awesome-react-aria');
+    expect(checkboxes[1]).toHaveAttribute('name', 'awesome-react-aria');
+    expect(checkboxes[2]).toHaveAttribute('name', 'awesome-react-aria');
+  });
+
+  it('supports labeling', () => {
+    let {getByRole} = render(
+      <CheckboxGroup
+        groupProps={{label: 'Favorite Pet'}}
+        checkboxProps={[
+          {value: 'dogs', children: 'Dogs'},
+          {value: 'cats', children: 'Cats'},
+          {value: 'dragons', children: 'Dragons'}
+        ]} />
+    );
+    let checkboxGroup = getByRole('group', {exact: true});
+
+    let labelId = checkboxGroup.getAttribute('aria-labelledby');
+    expect(labelId).toBeDefined();
+    let label = document.getElementById(labelId);
+    expect(label).toHaveTextContent('Favorite Pet');
+  });
+
+  it('supports aria-label', () => {
+    let {getByRole} = render(
+      <CheckboxGroup
+        groupProps={{'aria-label': 'My Favorite Pet'}}
+        checkboxProps={[
+          {value: 'dogs', children: 'Dogs'},
+          {value: 'cats', children: 'Cats'},
+          {value: 'dragons', children: 'Dragons'}
+        ]} />
+    );
+    let checkboxGroup = getByRole('group', {exact: true});
+
+    expect(checkboxGroup).toHaveAttribute('aria-label', 'My Favorite Pet');
+  });
+
+  it('supports custom props', () => {
+    const groupProps = {label: 'Favorite Pet', 'data-testid': 'favorite-pet'};
+    let {getByRole} = render(
+      <CheckboxGroup
+        groupProps={groupProps}
+        checkboxProps={[
+          {value: 'dogs', children: 'Dogs'},
+          {value: 'cats', children: 'Cats'},
+          {value: 'dragons', children: 'Dragons'}
+        ]} />
+    );
+    let checkboxGroup = getByRole('group', {exact: true});
+
+    expect(checkboxGroup).toHaveAttribute('data-testid', 'favorite-pet');
+  });
+
+  it('sets aria-disabled when isDisabled is true', () => {
+    let {getByRole} = render(
+      <CheckboxGroup
+        groupProps={{label: 'Favorite Pet', isDisabled: true}}
+        checkboxProps={[
+          {value: 'dogs', children: 'Dogs'},
+          {value: 'cats', children: 'Cats'},
+          {value: 'dragons', children: 'Dragons'}
+        ]} />
+    );
+    let checkboxGroup = getByRole('group', {exact: true});
+
+    expect(checkboxGroup).toHaveAttribute('aria-disabled', 'true');
+  });
+
+  it('doesn\'t set aria-disabled by default', () => {
+    let {getByRole} = render(
+      <CheckboxGroup
+        groupProps={{label: 'Favorite Pet'}}
+        checkboxProps={[
+          {value: 'dogs', children: 'Dogs'},
+          {value: 'cats', children: 'Cats'},
+          {value: 'dragons', children: 'Dragons'}
+        ]} />
+    );
+    let checkboxGroup = getByRole('group', {exact: true});
+
+    expect(checkboxGroup).not.toHaveAttribute('aria-disabled');
+  });
+
+  it('doesn\'t set aria-disabled when isDisabled is false', () => {
+    let {getByRole} = render(
+      <CheckboxGroup
+        groupProps={{label: 'Favorite Pet', isDisabled: false}}
+        checkboxProps={[
+          {value: 'dogs', children: 'Dogs'},
+          {value: 'cats', children: 'Cats'},
+          {value: 'dragons', children: 'Dragons'}
+        ]} />
+    );
+    let checkboxGroup = getByRole('group', {exact: true});
+
+    expect(checkboxGroup).not.toHaveAttribute('aria-disabled');
+  });
+
+  it('should not update state for readonly checkbox', () => {
+    let groupOnChangeSpy = jest.fn();
+    let checkboxOnChangeSpy = jest.fn();
+    let {getAllByRole, getByLabelText} = render(
+      <CheckboxGroup
+        groupProps={{label: 'Favorite Pet', onChange: groupOnChangeSpy}}
+        checkboxProps={[
+          {value: 'dogs', children: 'Dogs'},
+          {value: 'cats', children: 'Cats'},
+          {value: 'dragons', children: 'Dragons', isReadOnly: true, onChange: checkboxOnChangeSpy}
+        ]} />
+    );
+
+    let checkboxes = getAllByRole('checkbox') as HTMLInputElement[];
+    let dragons = getByLabelText('Dragons');
+
+    act(() => {userEvent.click(dragons);});
+
+    expect(groupOnChangeSpy).toHaveBeenCalledTimes(0);
+    expect(checkboxOnChangeSpy).toHaveBeenCalledTimes(0);
+    expect(checkboxes[2].checked).toBe(false);
+  });
+});
diff --git a/packages/@react-spectrum/checkbox/package.json b/packages/@react-spectrum/checkbox/package.json
index f12719bfad7..fc186fb0bba 100644
--- a/packages/@react-spectrum/checkbox/package.json
+++ b/packages/@react-spectrum/checkbox/package.json
@@ -36,6 +36,7 @@
     "@react-aria/focus": "^3.1.0",
     "@react-aria/interactions": "^3.1.0",
     "@react-spectrum/utils": "^3.1.0",
+    "@react-stately/checkbox": "^3.1.0",
     "@react-stately/toggle": "^3.1.0",
     "@react-types/checkbox": "^3.1.0",
     "@react-types/shared": "^3.1.0",
diff --git a/packages/@react-stately/checkbox/README.md b/packages/@react-stately/checkbox/README.md
new file mode 100644
index 00000000000..cec3b216977
--- /dev/null
+++ b/packages/@react-stately/checkbox/README.md
@@ -0,0 +1,3 @@
+# @react-stately/checkbox
+
+This package is part of [react-spectrum](https://github.com/adobe/react-spectrum). See the repo for more details.
diff --git a/packages/@react-stately/checkbox/docs/useCheckboxGroupState.mdx b/packages/@react-stately/checkbox/docs/useCheckboxGroupState.mdx
new file mode 100644
index 00000000000..5970788609b
--- /dev/null
+++ b/packages/@react-stately/checkbox/docs/useCheckboxGroupState.mdx
@@ -0,0 +1,36 @@
+<!-- Copyright 2020 Adobe. All rights reserved.
+This file is licensed to you under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License. You may obtain a copy
+of the License at http://www.apache.org/licenses/LICENSE-2.0
+Unless required by applicable law or agreed to in writing, software distributed under
+the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+OF ANY KIND, either express or implied. See the License for the specific language
+governing permissions and limitations under the License. -->
+
+import {Layout} from '@react-spectrum/docs';
+export default Layout;
+
+import docs from 'docs:@react-stately/checkbox';
+import {ClassAPI, HeaderInfo, TypeContext, FunctionAPI, TypeLink} from '@react-spectrum/docs';
+import packageData from '@react-stately/checkbox/package.json';
+
+---
+category: Forms
+keywords: [toggle, checkbox, switch, input, state]
+---
+
+# useCheckboxGroupState
+
+<p>{docs.exports.useCheckboxGroupState.description}</p>
+
+<HeaderInfo
+  packageData={packageData}
+  componentNames={['useCheckboxGroupState']} />
+
+## API
+
+<FunctionAPI function={docs.exports.useCheckboxGroupState} links={docs.links} />
+
+## Interface
+
+<ClassAPI links={docs.links} class={docs.links[docs.exports.useCheckboxGroupState.return.id]} />
diff --git a/packages/@react-stately/checkbox/index.ts b/packages/@react-stately/checkbox/index.ts
new file mode 100644
index 00000000000..1210ae1e402
--- /dev/null
+++ b/packages/@react-stately/checkbox/index.ts
@@ -0,0 +1,13 @@
+/*
+ * Copyright 2020 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+
+export * from './src';
diff --git a/packages/@react-stately/checkbox/package.json b/packages/@react-stately/checkbox/package.json
new file mode 100644
index 00000000000..8e75509bf6f
--- /dev/null
+++ b/packages/@react-stately/checkbox/package.json
@@ -0,0 +1,31 @@
+{
+  "name": "@react-stately/checkbox",
+  "version": "3.1.0",
+  "description": "Spectrum UI components in React",
+  "license": "Apache-2.0",
+  "main": "dist/main.js",
+  "module": "dist/module.js",
+  "types": "dist/types.d.ts",
+  "source": "src/index.ts",
+  "files": [
+    "dist",
+    "src"
+  ],
+  "sideEffects": false,
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/adobe/react-spectrum"
+  },
+  "dependencies": {
+    "@babel/runtime": "^7.6.2",
+    "@react-stately/toggle": "^3.1.0",
+    "@react-stately/utils": "^3.1.0",
+    "@react-types/checkbox": "^3.1.0"
+  },
+  "peerDependencies": {
+    "react": "^16.8.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}
diff --git a/packages/@react-stately/checkbox/src/index.ts b/packages/@react-stately/checkbox/src/index.ts
new file mode 100644
index 00000000000..c12402a5b8a
--- /dev/null
+++ b/packages/@react-stately/checkbox/src/index.ts
@@ -0,0 +1,13 @@
+/*
+ * Copyright 2020 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+
+export * from './useCheckboxGroupState';
diff --git a/packages/@react-stately/checkbox/src/useCheckboxGroupState.ts b/packages/@react-stately/checkbox/src/useCheckboxGroupState.ts
new file mode 100644
index 00000000000..918134e4801
--- /dev/null
+++ b/packages/@react-stately/checkbox/src/useCheckboxGroupState.ts
@@ -0,0 +1,88 @@
+/*
+ * Copyright 2020 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+
+import {CheckboxGroupProps} from '@react-types/checkbox';
+import {useControlledState} from '@react-stately/utils';
+import {useMemo} from 'react';
+
+export interface CheckboxGroupState {
+  /** The name for the group, used for native form submission. */
+  readonly name: string,
+
+  /** Current selected values. */
+  readonly value: readonly string[],
+
+  /** Sets the selected values. */
+  setValue(value: string[]): void,
+
+  /** Adds a value to the set of selected values. */
+  addValue(value: string): void,
+
+  /** Removes a value from the set of selected values. */
+  removeValue(value: string): void,
+
+  /** Toggles a value in the set of selected values. */
+  toggleValue(value: string): void
+}
+
+let instance = Math.round(Math.random() * 10000000000);
+let i = 0;
+
+/**
+ * Provides state management for a checkbox group component. Provides a name for the group,
+ * and manages selection and focus state.
+ */
+export function useCheckboxGroupState(props: CheckboxGroupProps = {}): CheckboxGroupState {
+  let name = useMemo(() => props.name || `checkbox-group-${instance}-${++i}`, [props.name]);
+  let [selectedValue, setValue] = useControlledState(props.value, props.defaultValue || [], props.onChange);
+
+  const state: CheckboxGroupState = {
+    name,
+    value: selectedValue,
+    setValue,
+    addValue(value) {
+      if (props.isReadOnly) {
+        return;
+      }
+      setValue(values => {
+        if (!values.includes(value)) {
+          return values.concat(value);
+        }
+        return values;
+      });
+    },
+    removeValue(value) {
+      if (props.isReadOnly) {
+        return;
+      }
+      setValue(values => {
+        if (values.includes(value)) {
+          return values.filter(existingValue => existingValue !== value);
+        }
+        return values;
+      });
+    },
+    toggleValue(value) {
+      if (props.isReadOnly) {
+        return;
+      }
+      setValue(values => {
+        if (values.includes(value)) {
+          return values.filter(existingValue => existingValue !== value);
+        }
+        return values.concat(value);
+      });
+    }
+  };
+
+  return state;
+}
diff --git a/packages/@react-stately/checkbox/test/useCheckboxGroupState.test.tsx b/packages/@react-stately/checkbox/test/useCheckboxGroupState.test.tsx
new file mode 100644
index 00000000000..912ee5302d2
--- /dev/null
+++ b/packages/@react-stately/checkbox/test/useCheckboxGroupState.test.tsx
@@ -0,0 +1,245 @@
+/*
+ * Copyright 2020 Adobe. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+
+import {act, render} from '@testing-library/react';
+import React from 'react';
+import {useCheckboxGroupState} from '../';
+
+describe('useCheckboxGroupState', () => {
+  it('should return basic interface when no props are provided', () => {
+    function Test() {
+      const state = useCheckboxGroupState();
+
+      expect(typeof state.name).toBe('string');
+      expect(state.value).toEqual([]);
+      expect(typeof state.setValue).toBe('function');
+      expect(typeof state.addValue).toBe('function');
+      expect(typeof state.removeValue).toBe('function');
+      expect(typeof state.toggleValue).toBe('function');
+
+      return null;
+    }
+    render(<Test />);
+  });
+
+  it('should return the same `name` that has been provided', () => {
+    function Test() {
+      const state = useCheckboxGroupState({name: 'foo'});
+
+      expect(state.name).toBe('foo');
+
+      return null;
+    }
+    render(<Test />);
+  });
+
+  it('should be possible to provide the initial value', () => {
+    function Test() {
+      const state = useCheckboxGroupState({value: ['foo', 'bar']});
+
+      expect(state.value).toEqual(['foo', 'bar']);
+
+      return null;
+    }
+    render(<Test />);
+  });
+
+  it('should be possible to provide a default value', () => {
+    function Test() {
+      const state = useCheckboxGroupState({defaultValue: ['foo', 'bar']});
+
+      expect(state.value).toEqual(['foo', 'bar']);
+
+      return null;
+    }
+    render(<Test />);
+  });
+
+  it('should be possible to control the value', () => {
+    function Test({value}: {value: string[]}) {
+      const state = useCheckboxGroupState({value});
+      return <>{state.value.join(', ')}</>;
+    }
+    const {container, rerender} = render(<Test value={['foo']} />);
+
+    expect(container.textContent).toBe('foo');
+
+    rerender(<Test value={['foo', 'bar']} />);
+
+    expect(container.textContent).toBe('foo, bar');
+  });
+
+  it('should be possible to have the value uncontrolled', () => {
+    let setValue: (value: string[]) => void;
+    function Test() {
+      const state = useCheckboxGroupState({defaultValue: ['foo']});
+      setValue = state.setValue;
+      return <>{state.value.join(', ')}</>;
+    }
+    const {container} = render(<Test />);
+
+    expect(container.textContent).toBe('foo');
+
+    act(() => {
+      setValue(['foo', 'bar']);
+    });
+
+    expect(container.textContent).toBe('foo, bar');
+  });
+
+  it('should call the provided `onChange` callback whenever value changes', () => {
+    const onChangeSpy = jest.fn();
+    const nextValue = ['foo', 'bar'];
+    let setValue: (value: string[]) => void;
+
+    function Test() {
+      const state = useCheckboxGroupState({defaultValue: ['foo'], onChange: onChangeSpy});
+      setValue = state.setValue;
+      return <>{state.value.join(', ')}</>;
+    }
+
+    render(<Test />);
+
+    act(() => {
+      setValue(nextValue);
+    });
+
+    expect(onChangeSpy).toHaveBeenCalledWith(nextValue);
+  });
+
+  it('should be possible to add a value using `addValue`', () => {
+    let addValue: (value: string) => void;
+    function Test() {
+      const state = useCheckboxGroupState({defaultValue: ['foo']});
+      addValue = state.addValue;
+      return <>{state.value.join(', ')}</>;
+    }
+    const {container} = render(<Test />);
+
+    act(() => {
+      addValue('baz');
+    });
+
+    expect(container.textContent).toBe('foo, baz');
+  });
+
+  it('should not add the same value multiple times when using `addValue`', () => {
+    let addValue: (value: string) => void;
+    function Test() {
+      const state = useCheckboxGroupState({defaultValue: ['foo']});
+      addValue = state.addValue;
+      return <>{state.value.join(', ')}</>;
+    }
+    const {container} = render(<Test />);
+
+    act(() => {
+      addValue('baz');
+      addValue('baz');
+      addValue('baz');
+      addValue('baz');
+    });
+
+    expect(container.textContent).toBe('foo, baz');
+  });
+
+  it('should be possible to remove a value using `removeValue`', () => {
+    let removeValue: (value: string) => void;
+    function Test() {
+      const state = useCheckboxGroupState({defaultValue: ['foo', 'qwe']});
+      removeValue = state.removeValue;
+      return <>{state.value.join(', ')}</>;
+    }
+    const {container} = render(<Test />);
+
+    act(() => {
+      removeValue('foo');
+    });
+
+    expect(container.textContent).toBe('qwe');
+  });
+
+  it('should be possible to add & remove value based on it being or not in the stored value using `toggleValue`', () => {
+    let toggleValue: (value: string) => void;
+    function Test() {
+      const state = useCheckboxGroupState({defaultValue: ['foo', 'qwe']});
+      toggleValue = state.toggleValue;
+      return <>{state.value.join(', ')}</>;
+    }
+    const {container} = render(<Test />);
+
+    act(() => {
+      toggleValue('foo');
+    });
+
+    expect(container.textContent).toBe('qwe');
+
+    act(() => {
+      toggleValue('foo');
+    });
+
+    expect(container.textContent).toBe('qwe, foo');
+  });
+
+  it('should go back to the initial value after `toggleState` being called twice with the same value synchronously', () => {
+    let toggleValue: (value: string) => void;
+    function Test() {
+      const state = useCheckboxGroupState({defaultValue: ['foo', 'qwe']});
+      toggleValue = state.toggleValue;
+      return <>{state.value.join(', ')}</>;
+    }
+    const {container} = render(<Test />);
+
+    act(() => {
+      toggleValue('qwe');
+      toggleValue('qwe');
+    });
+
+    expect(container.textContent).toBe('foo, qwe');
+  });
+
+  it('should not update state for readonly group', () => {
+    let addValue: (value: string) => void;
+    let removeValue: (value: string) => void;
+    let toggleValue: (value: string) => void;
+
+    function Test() {
+      const state = useCheckboxGroupState({isReadOnly: true, defaultValue: ['test']});
+      addValue = state.addValue;
+      removeValue = state.removeValue;
+      toggleValue = state.toggleValue;
+
+      return <>{state.value.join(', ')}</>;
+    }
+
+    const {container} = render(<Test />);
+
+    expect(container.textContent).toBe('test');
+
+    act(() => {
+      addValue('foo');
+    });
+
+    expect(container.textContent).toBe('test');
+
+    act(() => {
+      removeValue('test');
+    });
+
+    expect(container.textContent).toBe('test');
+
+    act(() => {
+      toggleValue('foo');
+    });
+
+    expect(container.textContent).toBe('test');
+  });
+});
diff --git a/packages/@react-types/checkbox/src/index.d.ts b/packages/@react-types/checkbox/src/index.d.ts
index d5e766db5c3..92253e59063 100644
--- a/packages/@react-types/checkbox/src/index.d.ts
+++ b/packages/@react-types/checkbox/src/index.d.ts
@@ -13,11 +13,14 @@
 import {
   AriaLabelingProps,
   AriaValidationProps,
+  DOMProps,
   FocusableDOMProps,
   FocusableProps,
   InputBase,
+  LabelableProps,
   StyleProps,
-  Validation
+  Validation,
+  ValueBase
 } from '@react-types/shared';
 import {ReactNode} from 'react';
 
@@ -55,6 +58,13 @@ export interface AriaToggleProps extends ToggleProps, FocusableDOMProps, AriaLab
   'aria-controls'?: string
 }
 
+export interface CheckboxGroupProps extends ValueBase<string[]>, InputBase, LabelableProps {
+  /**
+   * The name of the CheckboxGroup, used when submitting an HTML form.
+   */
+  name?: string
+}
+
 export interface CheckboxProps extends ToggleProps {
   /**
    * Indeterminism is presentational only.
@@ -65,6 +75,10 @@ export interface CheckboxProps extends ToggleProps {
 
 export interface AriaCheckboxProps extends CheckboxProps, AriaToggleProps {}
 
+export interface AriaCheckboxGroupProps extends CheckboxGroupProps, DOMProps, AriaLabelingProps, AriaValidationProps {}
+
+export interface AriaCheckboxGroupItemProps extends Omit<AriaCheckboxProps, 'isSelected' | 'defaultSelected'> {}
+
 export interface SpectrumCheckboxProps extends AriaCheckboxProps, StyleProps {
   /**
    * This prop sets the emphasized style which provides visual prominence.