diff --git a/packages/@react-aria/checkbox/docs/useCheckboxGroup.mdx b/packages/@react-aria/checkbox/docs/useCheckboxGroup.mdx
new file mode 100644
index 00000000000..d3b35bfacf0
--- /dev/null
+++ b/packages/@react-aria/checkbox/docs/useCheckboxGroup.mdx
@@ -0,0 +1,142 @@
+<!-- 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-aria/checkbox';
+import hiddenDocs from 'docs:@react-aria/visually-hidden';
+import focusDocs from 'docs:@react-aria/focus';
+import statelyDocs from 'docs:@react-stately/checkbox';
+import {HeaderInfo, FunctionAPI, TypeContext, InterfaceType, TypeLink} from '@react-spectrum/docs';
+import packageData from '@react-aria/checkbox/package.json';
+
+```jsx import
+import {useCheckboxGroup, useCheckboxGroupItem} from '@react-aria/checkbox';
+```
+
+---
+category: Forms
+keywords: [checkbox, input, aria]
+after_version: 3.1.0
+---
+
+# useCheckboxGroup
+
+<p>{docs.exports.useCheckboxGroup.description}</p>
+
+<HeaderInfo
+  packageData={packageData}
+  componentNames={['useCheckboxGroup', 'useCheckboxGroupItem']}
+  sourceData={[
+    {type: 'W3C', url: 'https://www.w3.org/TR/wai-aria-practices/#checkbox'}
+  ]} />
+
+## API
+
+<FunctionAPI function={docs.exports.useCheckboxGroup} links={docs.links} />
+<FunctionAPI function={docs.exports.useCheckboxGroupItem} links={docs.links} />
+
+## Features
+
+Checkbox groups can be built in HTML with the
+[&lt;fieldset&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/fieldset)
+and [&lt;input&gt;](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/input) elements,
+however these can be difficult to style. `useCheckboxGroup` and `useCheckboxGroupItem` help achieve accessible
+checkbox groups that can be styled as needed.
+
+* Checkbox groups are exposed to assistive technology via ARIA
+* Each checkbox is built with a native HTML `<input>` element, which can be optionally visually
+  hidden to allow custom styling
+* Full support for browser features like form autofill
+* Keyboard focus management and cross browser normalization
+* Group and checkbox labeling support for assistive technology
+
+## Anatomy
+
+A checkbox group consists of a set of checkboxes, and a label. Each checkbox
+includes a label and a visual selection indicator. Zero or more checkboxes
+within the group can be selected at a time. Users may click or touch a checkbox
+to select it, or use the <kbd>Tab</kbd> key to navigate to it
+and the <kbd>Space</kbd> key to toggle it.
+
+`useCheckboxGroup` returns props for the group and its label, which you should spread
+onto the appropriate element:
+
+<TypeContext.Provider value={docs.links}>
+  <InterfaceType properties={docs.links[docs.exports.useCheckboxGroup.return.id].properties} />
+</TypeContext.Provider>
+
+`useCheckboxGroupItem` returns props for an individual checkbox:
+
+<TypeContext.Provider value={docs.links}>
+  <InterfaceType properties={docs.links[docs.exports.useCheckboxGroupItem.return.id].properties} />
+</TypeContext.Provider>
+
+Selection state is managed by the <TypeLink links={statelyDocs.links} type={statelyDocs.exports.useCheckboxGroupState} />
+hook in `@react-stately/checkbox`. The state object should be passed as an option to `useCheckboxGroup`
+and `useCheckboxGroupItem`.
+
+Individual checkboxes must have a visual label. If the checkbox group does not have a visible label,
+an `aria-label` or `aria-labelledby` prop must be passed instead to identify the element to assistive
+technology.
+
+**Note:** `useCheckboxGroupItem` should only be used when it is contained within a checkbox group. For a
+standalone checkbox, use the [useCheckbox](useCheckbox.html) hook instead.
+
+## Example
+
+This example uses native input elements for the checkboxes, and React context to share state from the group
+to each checkbox. An HTML `<label>` element wraps the native input and the text to provide an implicit label
+for the radio.
+
+```tsx example
+import {useCheckboxGroupState} from '@react-stately/checkbox';
+
+let CheckboxGroupContext = React.createContext();
+
+function CheckboxGroup(props) {
+  let {children, label} = props;
+  let state = useCheckboxGroupState(props);
+  let {groupProps, labelProps} = useCheckboxGroup(props, state);
+
+  return (
+    <div {...groupProps}>
+      <span {...labelProps}>{label}</span>
+      <CheckboxGroupContext.Provider value={state}>
+        {children}
+      </CheckboxGroupContext.Provider>
+    </div>
+  );
+}
+
+function Checkbox(props) {
+  let {children} = props;
+  let state = React.useContext(CheckboxGroupContext);
+  let ref = React.useRef();
+  let {inputProps} = useCheckboxGroupItem(props, state, ref);
+
+  return (
+    <label style={{display: 'block'}}>
+      <input {...inputProps} />
+      {children}
+    </label>
+  );
+}
+
+<CheckboxGroup label="Favorite sports">
+  <Checkbox value="soccer">Soccer</Checkbox>
+  <Checkbox value="baseball">Baseball</Checkbox>
+  <Checkbox value="basketball">Basketball</Checkbox>
+</CheckboxGroup>
+```
+
+## Styling
+
+See the [useCheckbox](useCheckbox.html#styling) docs for details on how to customize the styling of checkbox elements.
diff --git a/packages/@react-aria/checkbox/src/useCheckboxGroup.ts b/packages/@react-aria/checkbox/src/useCheckboxGroup.ts
index 28be095a42e..ecf2e2f20aa 100644
--- a/packages/@react-aria/checkbox/src/useCheckboxGroup.ts
+++ b/packages/@react-aria/checkbox/src/useCheckboxGroup.ts
@@ -11,13 +11,15 @@
  */
 
 import {AriaCheckboxGroupProps} from '@react-types/checkbox';
+import {checkboxGroupNames} from './utils';
+import {CheckboxGroupState} from '@react-stately/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>,
+  groupProps: HTMLAttributes<HTMLElement>,
   /** Props for the checkbox group's visible label (if any). */
   labelProps: HTMLAttributes<HTMLElement>
 }
@@ -28,8 +30,8 @@ interface CheckboxGroupAria {
  * @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;
+export function useCheckboxGroup(props: AriaCheckboxGroupProps, state: CheckboxGroupState): CheckboxGroupAria {
+  let {isDisabled, name} = props;
 
   let {labelProps, fieldProps} = useLabel({
     ...props,
@@ -40,8 +42,11 @@ export function useCheckboxGroup(props: AriaCheckboxGroupProps): CheckboxGroupAr
 
   let domProps = filterDOMProps(props, {labelable: true});
 
+  // Pass name prop from group to all items by attaching to the state.
+  checkboxGroupNames.set(state, name);
+
   return {
-    checkboxGroupProps: mergeProps(domProps, {
+    groupProps: mergeProps(domProps, {
       role: 'group',
       'aria-disabled': isDisabled || undefined,
       ...fieldProps
diff --git a/packages/@react-aria/checkbox/src/useCheckboxGroupItem.ts b/packages/@react-aria/checkbox/src/useCheckboxGroupItem.ts
index 5a917eca608..de7c42f9082 100644
--- a/packages/@react-aria/checkbox/src/useCheckboxGroupItem.ts
+++ b/packages/@react-aria/checkbox/src/useCheckboxGroupItem.ts
@@ -12,6 +12,7 @@
 
 import {AriaCheckboxGroupItemProps} from '@react-types/checkbox';
 import {CheckboxAria, useCheckbox} from './useCheckbox';
+import {checkboxGroupNames} from './utils';
 import {CheckboxGroupState} from '@react-stately/checkbox';
 import {RefObject} from 'react';
 import {useToggleState} from '@react-stately/toggle';
@@ -25,8 +26,8 @@ import {useToggleState} from '@react-stately/toggle';
  */
 export function useCheckboxGroupItem(props: AriaCheckboxGroupItemProps, state: CheckboxGroupState, inputRef: RefObject<HTMLInputElement>): CheckboxAria {
   const toggleState = useToggleState({
-    isReadOnly: props.isReadOnly,
-    isSelected: state.value.includes(props.value),
+    isReadOnly: props.isReadOnly || state.isReadOnly,
+    isSelected: state.isSelected(props.value),
     onChange(isSelected) {
       if (isSelected) {
         state.addValue(props.value);
@@ -39,5 +40,13 @@ export function useCheckboxGroupItem(props: AriaCheckboxGroupItemProps, state: C
       }
     }
   });
-  return useCheckbox({...props, name: state.name}, toggleState, inputRef);
+
+  let {inputProps} = useCheckbox({
+    ...props,
+    isReadOnly: props.isReadOnly || state.isReadOnly,
+    isDisabled: props.isDisabled || state.isDisabled,
+    name: props.name || checkboxGroupNames.get(state)
+  }, toggleState, inputRef);
+
+  return {inputProps};
 }
diff --git a/packages/@react-aria/checkbox/src/utils.ts b/packages/@react-aria/checkbox/src/utils.ts
new file mode 100644
index 00000000000..3161b05cd4c
--- /dev/null
+++ b/packages/@react-aria/checkbox/src/utils.ts
@@ -0,0 +1,15 @@
+/*
+ * 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 {CheckboxGroupState} from '@react-stately/checkbox';
+
+export const checkboxGroupNames = new WeakMap<CheckboxGroupState, string>();
diff --git a/packages/@react-aria/checkbox/test/useCheckboxGroup.test.tsx b/packages/@react-aria/checkbox/test/useCheckboxGroup.test.tsx
index c1f2e477c58..8fd73c4ae72 100644
--- a/packages/@react-aria/checkbox/test/useCheckboxGroup.test.tsx
+++ b/packages/@react-aria/checkbox/test/useCheckboxGroup.test.tsx
@@ -26,7 +26,7 @@ function Checkbox({checkboxGroupState, ...props}: AriaCheckboxProps & { checkbox
 
 function CheckboxGroup({groupProps, checkboxProps}: {groupProps: AriaCheckboxGroupProps, checkboxProps: AriaCheckboxProps[]}) {
   const state = useCheckboxGroupState(groupProps);
-  const {checkboxGroupProps, labelProps} = useCheckboxGroup(groupProps);
+  const {groupProps: checkboxGroupProps, labelProps} = useCheckboxGroup(groupProps, state);
   return (
     <div {...checkboxGroupProps}>
       {groupProps.label && <span {...labelProps}>{groupProps.label}</span>}
@@ -55,10 +55,9 @@ describe('useCheckboxGroup', () => {
     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]).not.toHaveAttribute('name');
+    expect(checkboxes[1]).not.toHaveAttribute('name');
+    expect(checkboxes[2]).not.toHaveAttribute('name');
 
     expect(checkboxes[0].value).toBe('dogs');
     expect(checkboxes[1].value).toBe('cats');
@@ -159,8 +158,8 @@ describe('useCheckboxGroup', () => {
     expect(checkboxGroup).toHaveAttribute('data-testid', 'favorite-pet');
   });
 
-  it('sets aria-disabled when isDisabled is true', () => {
-    let {getByRole} = render(
+  it('sets aria-disabled and makes checkboxes disabled when isDisabled is true', () => {
+    let {getAllByRole, getByRole} = render(
       <CheckboxGroup
         groupProps={{label: 'Favorite Pet', isDisabled: true}}
         checkboxProps={[
@@ -169,13 +168,18 @@ describe('useCheckboxGroup', () => {
           {value: 'dragons', children: 'Dragons'}
         ]} />
     );
-    let checkboxGroup = getByRole('group', {exact: true});
 
+    let checkboxGroup = getByRole('group', {exact: true});
     expect(checkboxGroup).toHaveAttribute('aria-disabled', 'true');
+
+    let checkboxes = getAllByRole('checkbox') as HTMLInputElement[];
+    expect(checkboxes[0]).toHaveAttribute('disabled');
+    expect(checkboxes[0]).toHaveAttribute('disabled');
+    expect(checkboxes[0]).toHaveAttribute('disabled');
   });
 
-  it('doesn\'t set aria-disabled by default', () => {
-    let {getByRole} = render(
+  it('doesn\'t set aria-disabled or make checkboxes disabled by default', () => {
+    let {getAllByRole, getByRole} = render(
       <CheckboxGroup
         groupProps={{label: 'Favorite Pet'}}
         checkboxProps={[
@@ -184,13 +188,18 @@ describe('useCheckboxGroup', () => {
           {value: 'dragons', children: 'Dragons'}
         ]} />
     );
-    let checkboxGroup = getByRole('group', {exact: true});
 
+    let checkboxGroup = getByRole('group', {exact: true});
     expect(checkboxGroup).not.toHaveAttribute('aria-disabled');
+
+    let checkboxes = getAllByRole('checkbox') as HTMLInputElement[];
+    expect(checkboxes[0]).not.toHaveAttribute('disabled');
+    expect(checkboxes[0]).not.toHaveAttribute('disabled');
+    expect(checkboxes[0]).not.toHaveAttribute('disabled');
   });
 
-  it('doesn\'t set aria-disabled when isDisabled is false', () => {
-    let {getByRole} = render(
+  it('doesn\'t set aria-disabled or make checkboxes disabled when isDisabled is false', () => {
+    let {getAllByRole, getByRole} = render(
       <CheckboxGroup
         groupProps={{label: 'Favorite Pet', isDisabled: false}}
         checkboxProps={[
@@ -199,9 +208,31 @@ describe('useCheckboxGroup', () => {
           {value: 'dragons', children: 'Dragons'}
         ]} />
     );
-    let checkboxGroup = getByRole('group', {exact: true});
 
+    let checkboxGroup = getByRole('group', {exact: true});
     expect(checkboxGroup).not.toHaveAttribute('aria-disabled');
+
+    let checkboxes = getAllByRole('checkbox') as HTMLInputElement[];
+    expect(checkboxes[0]).not.toHaveAttribute('disabled');
+    expect(checkboxes[0]).not.toHaveAttribute('disabled');
+    expect(checkboxes[0]).not.toHaveAttribute('disabled');
+  });
+
+  it('sets readOnly on each checkbox', () => {
+    let {getAllByRole} = render(
+      <CheckboxGroup
+        groupProps={{label: 'Favorite Pet', isReadOnly: true}}
+        checkboxProps={[
+          {value: 'dogs', children: 'Dogs'},
+          {value: 'cats', children: 'Cats'},
+          {value: 'dragons', children: 'Dragons'}
+        ]} />
+    );
+
+    let checkboxes = getAllByRole('checkbox') as HTMLInputElement[];
+    expect(checkboxes[0]).toHaveAttribute('readonly');
+    expect(checkboxes[0]).toHaveAttribute('readonly');
+    expect(checkboxes[0]).toHaveAttribute('readonly');
   });
 
   it('should not update state for readonly checkbox', () => {
diff --git a/packages/@react-spectrum/checkbox/docs/CheckboxGroup.mdx b/packages/@react-spectrum/checkbox/docs/CheckboxGroup.mdx
new file mode 100644
index 00000000000..b5e27d0105e
--- /dev/null
+++ b/packages/@react-spectrum/checkbox/docs/CheckboxGroup.mdx
@@ -0,0 +1,273 @@
+<!-- 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-spectrum/checkbox';
+import packageData from '@react-spectrum/checkbox/package.json';
+import {HeaderInfo, PropTable} from '@react-spectrum/docs';
+
+```jsx import
+ import {Checkbox, CheckboxGroup} from '@react-spectrum/checkbox';
+ import {Flex} from '@react-spectrum/layout';
+ ```
+
+---
+category: Forms
+keywords: [input, checkbox group, accessibility]
+after_version: 3.1.0
+---
+
+# CheckboxGroup
+
+<p>{docs.exports.CheckboxGroup.description}</p>
+
+<HeaderInfo
+ packageData={packageData}
+ componentNames={['CheckboxGroup', 'Checkbox']}
+ sourceData={[
+ {type: 'Spectrum', url: 'https://spectrum.adobe.com/page/checkbox/'}
+ ]} />
+
+## Example
+
+```tsx example
+<CheckboxGroup label="Favorite sports">
+  <Checkbox value="soccer">Soccer</Checkbox>
+  <Checkbox value="baseball">Baseball</Checkbox>
+  <Checkbox value="basketball">Basketball</Checkbox>
+</CheckboxGroup>
+```
+
+## Content
+
+CheckboxGroup accepts multiple [Checkbox](Checkbox.html) elements as children.
+Each Checkbox represents an option that can be selected, labeled by its children.
+
+## Value
+
+CheckboxGroup supports selecting zero or more items. An initial, uncontrolled value can be provided to the CheckboxGroup using the `defaultValue` prop.
+Alternatively, a controlled value can be provided using the `value` prop. Both of these props accept an array of selected items, which map to the
+`value` prop on each item.
+
+```tsx example
+function Example() {
+  let [selected, setSelected] = React.useState(['soccer', 'baseball']);
+
+  return (
+    <Flex gap="size-300">
+      <CheckboxGroup label="Favorite sports (uncontrolled)" defaultValue={['soccer', 'baseball']}>
+        <Checkbox value="soccer">Soccer</Checkbox>
+        <Checkbox value="baseball">Baseball</Checkbox>
+        <Checkbox value="basketball">Basketball</Checkbox>
+      </CheckboxGroup>
+
+      <CheckboxGroup label="Favorite sports (controlled)" value={selected} onChange={setSelected}>
+        <Checkbox value="soccer">Soccer</Checkbox>
+        <Checkbox value="baseball">Baseball</Checkbox>
+        <Checkbox value="basketball">Basketball</Checkbox>
+      </CheckboxGroup>
+    </Flex>
+  );
+}
+```
+
+## Labeling
+A visual label should be provided for the CheckboxGroup using the `label` prop. If the CheckboxGroup requires an option to be selected by the user,
+the `isRequired` and `necessityIndicator` props can be used to show a required state.
+
+```tsx example
+<Flex gap="size-300" wrap>
+  <CheckboxGroup label="Favorite sports">
+    <Checkbox value="soccer">Soccer</Checkbox>
+    <Checkbox value="baseball">Baseball</Checkbox>
+    <Checkbox value="basketball">Basketball</Checkbox>
+  </CheckboxGroup>
+  <CheckboxGroup label="Favorite sports" isRequired necessityIndicator="icon">
+    <Checkbox value="soccer">Soccer</Checkbox>
+    <Checkbox value="baseball">Baseball</Checkbox>
+    <Checkbox value="basketball">Basketball</Checkbox>
+  </CheckboxGroup>
+  <CheckboxGroup label="Favorite sports" isRequired necessityIndicator="label">
+    <Checkbox value="soccer">Soccer</Checkbox>
+    <Checkbox value="baseball">Baseball</Checkbox>
+    <Checkbox value="basketball">Basketball</Checkbox>
+  </CheckboxGroup>
+  <CheckboxGroup label="Favorite sports" necessityIndicator="label">
+    <Checkbox value="soccer">Soccer</Checkbox>
+    <Checkbox value="baseball">Baseball</Checkbox>
+    <Checkbox value="basketball">Basketball</Checkbox>
+  </CheckboxGroup>
+</Flex>
+```
+
+### Accessibility
+
+If a visible label isn't specified for a CheckboxGroup, an `aria-label` must be provided for accessibility. If the field is labeled by a separate element, an `aria-labelledby` prop must be provided using the id of the labeling element instead.
+
+Checkbox elements within a group should always have a visible label.
+
+### Internationalization
+
+To internationalize a CheckboxGroup, a localized string should be passed to the `label` prop and as the child content of the Checkbox elements.
+For languages that are read right-to-left (e.g. Hebrew and Arabic), the Checkbox is automatically placed on the right side of the text. When the necessityIndicator prop is set to "label", a localized string will be provided for "(required)" or "(optional)" automatically.
+
+## Events
+
+CheckboxGroup accepts an `onChange` prop, which is triggered when a user adds or removes an item from the selection.
+The example below uses `onChange` to log how the user is interacting with the component.
+
+```tsx example
+function Example() {
+  let [selected, setSelected] = React.useState([]);
+
+  return (
+    <>
+      <CheckboxGroup label="Favorite sports" value={selected} onChange={setSelected}>
+        <Checkbox value="soccer">Soccer</Checkbox>
+        <Checkbox value="baseball">Baseball</Checkbox>
+        <Checkbox value="basketball">Basketball</Checkbox>
+      </CheckboxGroup>
+      <div>You have selected: {selected.join(', ')}</div>
+    </>
+  );
+}
+```
+
+## Validation
+
+CheckboxGroups can display a validation state to communicate to the user if the current value is invalid.
+Implement your own validation logic in your app and pass `"invalid"` to the `validationState` prop to either
+the `CheckboxGroup` or an individual `Checkbox` to mark it as invalid.
+
+### Group validation
+
+If the group as a whole is invalid, for example if the user must choose at least one option but failed
+to do so, then pass `validationState="invalid"` to the `CheckboxGroup`.
+
+The following example shows how to require that at least one option is selected. It sets the `validationState`
+prop to `"invalid"` when no options are selected and removes it otherwise.
+
+```tsx example
+function Example() {
+  let [selected, setSelected] = React.useState([]);
+
+  return (
+    <CheckboxGroup label="Sandwich condiments" value={selected} onChange={setSelected} isRequired validationState={selected.length === 0 ? 'invalid' : null}>
+      <Checkbox value="lettuce">Lettuce</Checkbox>
+      <Checkbox value="tomato">Tomato</Checkbox>
+      <Checkbox value="onion">Onion</Checkbox>
+      <Checkbox value="sprouts">Sprouts</Checkbox>
+    </CheckboxGroup>
+  );
+}
+```
+
+### Individual Checkbox validation
+
+If an individual checkbox is invalid, for example if the user must select a particular option but failed
+to do so, then pass `validationState="invalid"` to the `Checkbox` element instead.
+
+The following example shows how to require that all items are selected. It uses the `isRequired` prop on each individual `Checkbox`
+element to indicate to assistive technology that every checkbox is required. By default, the `isRequired` prop on the `CheckboxGroup` only
+indicates that the group is required, not any individual option. In addition, `validationState="invalid"` is set on each checkbox that is not yet checked.
+
+```tsx example
+function Example() {
+  let [selected, setSelected] = React.useState([]);
+
+  return (
+    <CheckboxGroup label="Agree to the following" isRequired value={selected} onChange={setSelected}>
+      <Checkbox value="terms" isRequired validationState={!selected.includes('terms') ? 'invalid' : null}>Terms and conditions</Checkbox>
+      <Checkbox value="privacy" isRequired validationState={!selected.includes('privacy') ? 'invalid' : null}>Privacy policy</Checkbox>
+      <Checkbox value="cookies" isRequired validationState={!selected.includes('cookies') ? 'invalid' : null}>Cookie policy</Checkbox>
+    </CheckboxGroup>
+  );
+}
+```
+
+## Props
+
+<PropTable component={docs.exports.CheckboxGroup} links={docs.links} />
+
+## Visual options
+
+### Orientation
+
+CheckboxGroups are vertically oriented by default.
+The `orientation` prop can be used to change the orientation to horizontal.
+
+```tsx example
+<CheckboxGroup label="Favorite sports" orientation="horizontal">
+  <Checkbox value="soccer">Soccer</Checkbox>
+  <Checkbox value="baseball">Baseball</Checkbox>
+  <Checkbox value="basketball">Basketball</Checkbox>
+</CheckboxGroup>
+```
+
+### Label position and alignment
+
+By default, the label is positioned above the CheckboxGroup.
+The `labelPosition` prop can be used to position the label to the side. The `labelAlign` prop can
+be used to align the label as "start" or "end".
+For left-to-right (LTR) languages, "start" refers to the left most edge of the CheckboxGroup
+and "end" refers to the right most edge. For right-to-left (RTL) languages, this is flipped.
+
+```tsx example
+<CheckboxGroup label="Favorite sports" labelPosition="side" labelAlign="end">
+  <Checkbox value="soccer">Soccer</Checkbox>
+  <Checkbox value="baseball">Baseball</Checkbox>
+  <Checkbox value="basketball">Basketball</Checkbox>
+</CheckboxGroup>
+```
+
+### Disabled
+[View guidelines](https://spectrum.adobe.com/page/checkbox/#Disabled)
+
+```tsx example
+<CheckboxGroup label="Favorite sports" isDisabled>
+  <Checkbox value="soccer">Soccer</Checkbox>
+  <Checkbox value="baseball">Baseball</Checkbox>
+  <Checkbox value="basketball">Basketball</Checkbox>
+</CheckboxGroup>
+```
+
+```tsx example
+<CheckboxGroup label="Favorite sports">
+  <Checkbox value="soccer">Soccer</Checkbox>
+  <Checkbox value="baseball" isDisabled>Baseball</Checkbox>
+  <Checkbox value="basketball">Basketball</Checkbox>
+</CheckboxGroup>
+```
+
+### Read only
+[View guidelines](https://spectrum.adobe.com/page/checkbox/#Read-only)
+
+The `isReadOnly` prop makes the selection immutable. Unlike `isDisabled`, the CheckboxGroup remains focusable.
+See the [MDN docs](https://developer.mozilla.org/en-US/docs/Web/HTML/Attributes/readonly) for more information.
+
+```tsx example
+<CheckboxGroup label="Favorite sports" defaultValue={['baseball']} isReadOnly>
+  <Checkbox value="soccer">Soccer</Checkbox>
+  <Checkbox value="baseball">Baseball</Checkbox>
+  <Checkbox value="basketball">Basketball</Checkbox>
+</CheckboxGroup>
+```
+
+### Emphasized
+[View guidelines](https://spectrum.adobe.com/page/checkbox/#Emphasis)
+
+```tsx example
+<CheckboxGroup label="Favorite sports" defaultValue={['soccer', 'baseball']} isEmphasized>
+  <Checkbox value="soccer">Soccer</Checkbox>
+  <Checkbox value="baseball">Baseball</Checkbox>
+  <Checkbox value="basketball">Basketball</Checkbox>
+</CheckboxGroup>
+```
diff --git a/packages/@react-spectrum/checkbox/package.json b/packages/@react-spectrum/checkbox/package.json
index fc186fb0bba..710f3fa16c6 100644
--- a/packages/@react-spectrum/checkbox/package.json
+++ b/packages/@react-spectrum/checkbox/package.json
@@ -35,6 +35,8 @@
     "@react-aria/checkbox": "^3.1.0",
     "@react-aria/focus": "^3.1.0",
     "@react-aria/interactions": "^3.1.0",
+    "@react-spectrum/form": "3.2.0",
+    "@react-spectrum/label": "3.2.0",
     "@react-spectrum/utils": "^3.1.0",
     "@react-stately/checkbox": "^3.1.0",
     "@react-stately/toggle": "^3.1.0",
diff --git a/packages/@react-spectrum/checkbox/src/Checkbox.tsx b/packages/@react-spectrum/checkbox/src/Checkbox.tsx
index 717610aac00..eea41f1cfe4 100644
--- a/packages/@react-spectrum/checkbox/src/Checkbox.tsx
+++ b/packages/@react-spectrum/checkbox/src/Checkbox.tsx
@@ -10,20 +10,22 @@
  * governing permissions and limitations under the License.
  */
 
+import {CheckboxGroupContext} from './context';
 import CheckmarkSmall from '@spectrum-icons/ui/CheckmarkSmall';
 import {classNames, useFocusableRef, useStyleProps} from '@react-spectrum/utils';
 import DashSmall from '@spectrum-icons/ui/DashSmall';
 import {FocusableRef} from '@react-types/shared';
 import {FocusRing} from '@react-aria/focus';
-import React, {forwardRef, useRef} from 'react';
+import React, {forwardRef, useContext, useRef} from 'react';
 import {SpectrumCheckboxProps} from '@react-types/checkbox';
 import styles from '@adobe/spectrum-css-temp/components/checkbox/vars.css';
-import {useCheckbox} from '@react-aria/checkbox';
+import {useCheckbox, useCheckboxGroupItem} from '@react-aria/checkbox';
 import {useHover} from '@react-aria/interactions';
 import {useProviderProps} from '@react-spectrum/provider';
 import {useToggleState} from '@react-stately/toggle';
 
 function Checkbox(props: SpectrumCheckboxProps, ref: FocusableRef<HTMLLabelElement>) {
+  let originalProps = props;
   props = useProviderProps(props);
   let {
     isIndeterminate = false,
@@ -31,6 +33,7 @@ function Checkbox(props: SpectrumCheckboxProps, ref: FocusableRef<HTMLLabelEleme
     isDisabled = false,
     autoFocus,
     children,
+    validationState,
     ...otherProps
   } = props;
   let {styleProps} = useStyleProps(otherProps);
@@ -38,13 +41,35 @@ function Checkbox(props: SpectrumCheckboxProps, ref: FocusableRef<HTMLLabelEleme
 
   let inputRef = useRef<HTMLInputElement>(null);
   let domRef = useFocusableRef(ref, inputRef);
-  let state = useToggleState(props);
-  let {inputProps} = useCheckbox(props, state, inputRef);
+
+  // Swap hooks depending on whether this checkbox is inside a CheckboxGroup.
+  // This is a bit unorthodox. Typically, hooks cannot be called in a conditional,
+  // but since the checkbox won't move in and out of a group, it should be safe.
+  let groupState = useContext(CheckboxGroupContext);
+  let {inputProps} = groupState
+    // eslint-disable-next-line react-hooks/rules-of-hooks
+    ? useCheckboxGroupItem({
+      ...props,
+      // Only pass isRequired and validationState to react-aria if they came from
+      // the props for this individual checkbox, and not from the group via context.
+      isRequired: originalProps.isRequired,
+      validationState: originalProps.validationState
+    }, groupState, inputRef)
+    // eslint-disable-next-line react-hooks/rules-of-hooks
+    : useCheckbox(props, useToggleState(props), inputRef);
 
   let markIcon = isIndeterminate
     ? <DashSmall UNSAFE_className={classNames(styles, 'spectrum-Checkbox-partialCheckmark')} />
     : <CheckmarkSmall UNSAFE_className={classNames(styles, 'spectrum-Checkbox-checkmark')} />;
 
+  if (groupState) {
+    for (let key of ['isSelected', 'defaultSelected', 'isEmphasized']) {
+      if (originalProps[key] != null) {
+        console.warn(`${key} is unsupported on individual <Checkbox> elements within a <CheckboxGroup>. Please apply these props to the group instead.`);
+      }
+    }
+  }
+
   return (
     <label
       {...styleProps}
@@ -55,10 +80,10 @@ function Checkbox(props: SpectrumCheckboxProps, ref: FocusableRef<HTMLLabelEleme
           styles,
           'spectrum-Checkbox',
           {
-            'is-checked': state.isSelected,
+            'is-checked': inputProps.checked,
             'is-indeterminate': isIndeterminate,
             'spectrum-Checkbox--quiet': !isEmphasized,
-            'is-invalid': inputProps['aria-invalid'],
+            'is-invalid': validationState === 'invalid',
             'is-disabled': isDisabled,
             'is-hovered': isHovered
           },
diff --git a/packages/@react-spectrum/checkbox/src/CheckboxGroup.tsx b/packages/@react-spectrum/checkbox/src/CheckboxGroup.tsx
new file mode 100644
index 00000000000..7069a5c5446
--- /dev/null
+++ b/packages/@react-spectrum/checkbox/src/CheckboxGroup.tsx
@@ -0,0 +1,103 @@
+/*
+ * 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 {CheckboxGroupContext} from './context';
+import {classNames, useDOMRef, useStyleProps} from '@react-spectrum/utils';
+import {DOMRef, LabelPosition} from '@react-types/shared';
+import {Label} from '@react-spectrum/label';
+import labelStyles from '@adobe/spectrum-css-temp/components/fieldlabel/vars.css';
+import {Provider, useProviderProps} from '@react-spectrum/provider';
+import React from 'react';
+import {SpectrumCheckboxGroupProps} from '@react-types/checkbox';
+import styles from '@adobe/spectrum-css-temp/components/fieldgroup/vars.css';
+import {useCheckboxGroup} from '@react-aria/checkbox';
+import {useCheckboxGroupState} from '@react-stately/checkbox';
+import {useFormProps} from '@react-spectrum/form';
+
+function CheckboxGroup(props: SpectrumCheckboxGroupProps, ref: DOMRef<HTMLDivElement>) {
+  props = useProviderProps(props);
+  props = useFormProps(props);
+  let {
+    isEmphasized,
+    isRequired,
+    necessityIndicator,
+    label,
+    labelPosition = 'top' as LabelPosition,
+    labelAlign,
+    children,
+    orientation = 'vertical',
+    validationState,
+    ...otherProps
+  } = props;
+  let domRef = useDOMRef(ref);
+  let {styleProps} = useStyleProps(otherProps);
+  let state = useCheckboxGroupState(props);
+  let {labelProps, groupProps} = useCheckboxGroup(props, state);
+
+  return (
+    <div
+      {...styleProps}
+      {...groupProps}
+      className={
+        classNames(
+          styles,
+          'spectrum-FieldGroup',
+          {
+            'spectrum-FieldGroup--positionSide': labelPosition === 'side'
+          },
+          // This is so checkbox group works inside a <Form>
+          classNames(
+            labelStyles,
+            'spectrum-Field'
+          ),
+          styleProps.className
+        )
+      }
+      ref={domRef}>
+      {label &&
+        <Label
+          {...labelProps}
+          elementType="span"
+          labelPosition={labelPosition}
+          labelAlign={labelAlign}
+          isRequired={isRequired}
+          necessityIndicator={necessityIndicator}
+          includeNecessityIndicatorInAccessibilityName>
+          {label}
+        </Label>
+      }
+      <div
+        role="presentation"
+        className={
+          classNames(
+            styles,
+            'spectrum-FieldGroup-group',
+            {
+              'spectrum-FieldGroup-group--horizontal': orientation === 'horizontal'
+            }
+          )
+        }>
+        <Provider isEmphasized={isEmphasized} validationState={validationState}>
+          <CheckboxGroupContext.Provider value={state}>
+            {children}
+          </CheckboxGroupContext.Provider>
+        </Provider>
+      </div>
+    </div>
+  );
+}
+
+/**
+ * A CheckboxGroup allows users to select one or more items from a list of choices.
+ */
+const _CheckboxGroup = React.forwardRef(CheckboxGroup);
+export {_CheckboxGroup as CheckboxGroup};
diff --git a/packages/@react-spectrum/checkbox/src/context.ts b/packages/@react-spectrum/checkbox/src/context.ts
new file mode 100644
index 00000000000..ffe139e6c57
--- /dev/null
+++ b/packages/@react-spectrum/checkbox/src/context.ts
@@ -0,0 +1,16 @@
+/*
+ * 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 {CheckboxGroupState} from '@react-stately/checkbox';
+import React from 'react';
+
+export const CheckboxGroupContext = React.createContext<CheckboxGroupState>(null);
diff --git a/packages/@react-spectrum/checkbox/src/index.ts b/packages/@react-spectrum/checkbox/src/index.ts
index 3f1ff02a498..111079ec916 100644
--- a/packages/@react-spectrum/checkbox/src/index.ts
+++ b/packages/@react-spectrum/checkbox/src/index.ts
@@ -13,3 +13,4 @@
 /// <reference types="css-module-types" />
 
 export * from './Checkbox';
+export * from './CheckboxGroup';
diff --git a/packages/@react-spectrum/checkbox/stories/CheckboxGroup.stories.tsx b/packages/@react-spectrum/checkbox/stories/CheckboxGroup.stories.tsx
new file mode 100644
index 00000000000..176294052d2
--- /dev/null
+++ b/packages/@react-spectrum/checkbox/stories/CheckboxGroup.stories.tsx
@@ -0,0 +1,106 @@
+/*
+ * 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 {action} from '@storybook/addon-actions';
+import {Checkbox, CheckboxGroup} from '../';
+import React from 'react';
+import {SpectrumCheckboxGroupProps} from '@react-types/checkbox';
+import {storiesOf} from '@storybook/react';
+
+storiesOf('CheckboxGroup', module)
+  .addParameters({providerSwitcher: {status: 'positive'}})
+  .add(
+    'Default',
+    () => render()
+  )
+  .add(
+    'defaultValue: dragons',
+    () => render({defaultValue: ['dragons']})
+  )
+  .add(
+    'controlled: dragons',
+    () => render({value: ['dragons']})
+  )
+  .add(
+    'labelPosition: side',
+    () => render({labelPosition: 'side'})
+  )
+  .add(
+    'labelAlign: end',
+    () => render({labelAlign: 'end'})
+  )
+  .add(
+    'horizontal',
+    () => render({orientation: 'horizontal'})
+  )
+  .add(
+    'horizontal, labelPosition: side',
+    () => render({orientation: 'horizontal', labelPosition: 'side'})
+  )
+  .add(
+    'horizontal, labelAlign: end',
+    () => render({orientation: 'horizontal', labelAlign: 'end'})
+  )
+  .add(
+    'isDisabled',
+    () => render({isDisabled: true})
+  )
+  .add(
+    'isDisabled on one checkbox',
+    () => render({}, [{}, {isDisabled: true}, {}])
+  )
+  .add(
+    'isDisabled on one checkbox horizontal',
+    () => render({orientation: 'horizontal'}, [{}, {isDisabled: true}, {}])
+  )
+  .add(
+    'isRequired',
+    () => render({isRequired: true})
+  )
+  .add(
+    'isReadOnly',
+    () => render({isReadOnly: true})
+  )
+  .add(
+    'isEmphasized',
+    () => render({isEmphasized: true})
+  )
+  .add(
+    'validationState: "invalid"',
+    () => render({validationState: 'invalid'})
+  )
+  .add(
+    'validationState: "invalid" on one checkbox',
+    () => render({}, [{}, {validationState: 'invalid'}, {}])
+  )
+  .add(
+    'no visible label',
+    () => render({label: null, 'aria-label': 'Pets'})
+  )
+  .add(
+    'autoFocus on one checkbox',
+    () => render({}, [{}, {autoFocus: true}, {}])
+  )
+  .add(
+    'form name',
+    () => render({name: 'pets'})
+  );
+
+function render(props: Omit<SpectrumCheckboxGroupProps, 'children'> = {}, checkboxProps: any[] = []) {
+  return (
+    <CheckboxGroup label="Pets" {...props} onChange={action('onChange')}>
+      <Checkbox value="dogs" {...checkboxProps[0]}>Dogs</Checkbox>
+      <Checkbox value="cats" {...checkboxProps[1]}>Cats</Checkbox>
+      <Checkbox value="dragons" {...checkboxProps[2]}>Dragons</Checkbox>
+    </CheckboxGroup>
+  );
+}
diff --git a/packages/@react-spectrum/checkbox/test/CheckboxGroup.test.js b/packages/@react-spectrum/checkbox/test/CheckboxGroup.test.js
new file mode 100644
index 00000000000..00cb4a4151a
--- /dev/null
+++ b/packages/@react-spectrum/checkbox/test/CheckboxGroup.test.js
@@ -0,0 +1,339 @@
+/*
+ * 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, within} from '@testing-library/react';
+import {Checkbox, CheckboxGroup} from '../';
+import {Provider} from '@react-spectrum/provider';
+import React from 'react';
+import {theme} from '@react-spectrum/theme-default';
+import userEvent from '@testing-library/user-event';
+
+describe('CheckboxGroup', () => {
+  it('handles defaults', () => {
+    let onChangeSpy = jest.fn();
+    let {getByRole, getAllByRole, getByLabelText} = render(
+      <Provider theme={theme}>
+        <CheckboxGroup label="Favorite Pet" onChange={onChangeSpy}>
+          <Checkbox value="dogs">Dogs</Checkbox>
+          <Checkbox value="cats">Cats</Checkbox>
+          <Checkbox value="dragons">Dragons</Checkbox>
+        </CheckboxGroup>
+      </Provider>
+    );
+
+    let checkboxGroup = getByRole('group', {exact: true});
+    let checkboxes = getAllByRole('checkbox');
+    expect(checkboxGroup).toBeInTheDocument();
+    expect(checkboxes.length).toBe(3);
+
+    expect(checkboxes[0]).not.toHaveAttribute('name');
+    expect(checkboxes[1]).not.toHaveAttribute('name');
+    expect(checkboxes[2]).not.toHaveAttribute('name');
+
+    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(
+      <Provider theme={theme}>
+        <CheckboxGroup label="Favorite Pet" value={['cats']}>
+          <Checkbox value="dogs">Dogs</Checkbox>
+          <Checkbox value="cats">Cats</Checkbox>
+          <Checkbox value="dragons">Dragons</Checkbox>
+        </CheckboxGroup>
+      </Provider>
+    );
+
+    expect(getByLabelText('Cats').checked).toBe(true);
+  });
+
+  it('name can be controlled', () => {
+    let {getAllByRole} = render(
+      <Provider theme={theme}>
+        <CheckboxGroup label="Favorite Pet" name="awesome-react-aria">
+          <Checkbox value="dogs">Dogs</Checkbox>
+          <Checkbox value="cats">Cats</Checkbox>
+          <Checkbox value="dragons">Dragons</Checkbox>
+        </CheckboxGroup>
+      </Provider>
+    );
+
+    let checkboxes = getAllByRole('checkbox');
+
+    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(
+      <Provider theme={theme}>
+        <CheckboxGroup label="Favorite Pet">
+          <Checkbox value="dogs">Dogs</Checkbox>
+          <Checkbox value="cats">Cats</Checkbox>
+          <Checkbox value="dragons">Dragons</Checkbox>
+        </CheckboxGroup>
+      </Provider>
+    );
+    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(
+      <Provider theme={theme}>
+        <CheckboxGroup aria-label="My Favorite Pet">
+          <Checkbox value="dogs">Dogs</Checkbox>
+          <Checkbox value="cats">Cats</Checkbox>
+          <Checkbox value="dragons">Dragons</Checkbox>
+        </CheckboxGroup>
+      </Provider>
+    );
+    let checkboxGroup = getByRole('group', {exact: true});
+
+    expect(checkboxGroup).toHaveAttribute('aria-label', 'My Favorite Pet');
+  });
+
+  it('supports custom props', () => {
+    let {getByRole} = render(
+      <Provider theme={theme}>
+        <CheckboxGroup label="Favorite Pet" data-testid="favorite-pet">
+          <Checkbox value="dogs">Dogs</Checkbox>
+          <Checkbox value="cats">Cats</Checkbox>
+          <Checkbox value="dragons">Dragons</Checkbox>
+        </CheckboxGroup>
+      </Provider>
+    );
+    let checkboxGroup = getByRole('group', {exact: true});
+
+    expect(checkboxGroup).toHaveAttribute('data-testid', 'favorite-pet');
+  });
+
+  it('sets aria-disabled when isDisabled is true', () => {
+    let {getAllByRole, getByRole} = render(
+      <Provider theme={theme}>
+        <CheckboxGroup label="Favorite Pet" isDisabled>
+          <Checkbox value="dogs">Dogs</Checkbox>
+          <Checkbox value="cats">Cats</Checkbox>
+          <Checkbox value="dragons">Dragons</Checkbox>
+        </CheckboxGroup>
+      </Provider>
+    );
+
+    let checkboxGroup = getByRole('group', {exact: true});
+    expect(checkboxGroup).toHaveAttribute('aria-disabled', 'true');
+
+    let checkboxes = getAllByRole('checkbox');
+    expect(checkboxes[0]).toHaveAttribute('disabled');
+    expect(checkboxes[1]).toHaveAttribute('disabled');
+    expect(checkboxes[2]).toHaveAttribute('disabled');
+  });
+
+  it('doesn\'t set aria-disabled by default', () => {
+    let {getAllByRole, getByRole} = render(
+      <Provider theme={theme}>
+        <CheckboxGroup label="Favorite Pet">
+          <Checkbox value="dogs">Dogs</Checkbox>
+          <Checkbox value="cats">Cats</Checkbox>
+          <Checkbox value="dragons">Dragons</Checkbox>
+        </CheckboxGroup>
+      </Provider>
+    );
+
+    let checkboxGroup = getByRole('group', {exact: true});
+    expect(checkboxGroup).not.toHaveAttribute('aria-disabled');
+
+    let checkboxes = getAllByRole('checkbox');
+    expect(checkboxes[0]).not.toHaveAttribute('disabled');
+    expect(checkboxes[1]).not.toHaveAttribute('disabled');
+    expect(checkboxes[2]).not.toHaveAttribute('disabled');
+  });
+
+  it('doesn\'t set aria-disabled when isDisabled is false', () => {
+    let {getAllByRole, getByRole} = render(
+      <Provider theme={theme}>
+        <CheckboxGroup label="Favorite Pet" isDisabled={false}>
+          <Checkbox value="dogs">Dogs</Checkbox>
+          <Checkbox value="cats">Cats</Checkbox>
+          <Checkbox value="dragons">Dragons</Checkbox>
+        </CheckboxGroup>
+      </Provider>
+    );
+
+    let checkboxGroup = getByRole('group', {exact: true});
+    expect(checkboxGroup).not.toHaveAttribute('aria-disabled');
+
+    let checkboxes = getAllByRole('checkbox');
+    expect(checkboxes[0]).not.toHaveAttribute('disabled');
+    expect(checkboxes[1]).not.toHaveAttribute('disabled');
+    expect(checkboxes[2]).not.toHaveAttribute('disabled');
+  });
+
+  it('sets readOnly on each checkbox', () => {
+    let {getAllByRole} = render(
+      <Provider theme={theme}>
+        <CheckboxGroup label="Favorite Pet" isReadOnly>
+          <Checkbox value="dogs">Dogs</Checkbox>
+          <Checkbox value="cats">Cats</Checkbox>
+          <Checkbox value="dragons">Dragons</Checkbox>
+        </CheckboxGroup>
+      </Provider>
+    );
+
+    let checkboxes = getAllByRole('checkbox');
+    expect(checkboxes[0]).toHaveAttribute('readonly');
+    expect(checkboxes[1]).toHaveAttribute('readonly');
+    expect(checkboxes[2]).toHaveAttribute('readonly');
+  });
+
+  it('should not update state for readonly checkbox', () => {
+    let groupOnChangeSpy = jest.fn();
+    let checkboxOnChangeSpy = jest.fn();
+    let {getAllByRole, getByLabelText} = render(
+      <Provider theme={theme}>
+        <CheckboxGroup label="Favorite Pet" onChange={groupOnChangeSpy}>
+          <Checkbox value="dogs">Dogs</Checkbox>
+          <Checkbox value="cats">Cats</Checkbox>
+          <Checkbox value="dragons" isReadOnly onChange={checkboxOnChangeSpy}>Dragons</Checkbox>
+        </CheckboxGroup>
+      </Provider>
+    );
+
+    let checkboxes = getAllByRole('checkbox');
+    let dragons = getByLabelText('Dragons');
+
+    act(() => {userEvent.click(dragons);});
+
+    expect(groupOnChangeSpy).toHaveBeenCalledTimes(0);
+    expect(checkboxOnChangeSpy).toHaveBeenCalledTimes(0);
+    expect(checkboxes[2].checked).toBe(false);
+  });
+
+  it('adds required to group label', () => {
+    let {getAllByRole, getByRole} = render(
+      <Provider theme={theme}>
+        <CheckboxGroup label="Favorite Pet" isRequired>
+          <Checkbox value="dogs">Dogs</Checkbox>
+          <Checkbox value="cats">Cats</Checkbox>
+          <Checkbox value="dragons">Dragons</Checkbox>
+        </CheckboxGroup>
+      </Provider>
+    );
+
+    let checkboxGroup = getByRole('group', {exact: true});
+    let labelId = checkboxGroup.getAttribute('aria-labelledby');
+    let label = document.getElementById(labelId);
+    expect(label).toHaveTextContent('Favorite Pet');
+
+    let necessityIndicator = within(label).getByRole('img');
+    expect(necessityIndicator).toHaveAttribute('aria-label', '(required)');
+
+    let checkboxes = getAllByRole('checkbox');
+    expect(checkboxes[0]).not.toHaveAttribute('required');
+    expect(checkboxes[1]).not.toHaveAttribute('required');
+    expect(checkboxes[2]).not.toHaveAttribute('required');
+  });
+
+  it('supports isRequired on individual checkboxes', () => {
+    let {getAllByRole, getByRole} = render(
+      <Provider theme={theme}>
+        <CheckboxGroup label="Agree to the following" isRequired>
+          <Checkbox value="terms" isRequired>Terms and conditions</Checkbox>
+          <Checkbox value="cookies" isRequired>Cookies</Checkbox>
+          <Checkbox value="privacy" isRequired>Privacy policy</Checkbox>
+        </CheckboxGroup>
+      </Provider>
+    );
+
+    let checkboxGroup = getByRole('group', {exact: true});
+    let labelId = checkboxGroup.getAttribute('aria-labelledby');
+    let label = document.getElementById(labelId);
+    expect(label).toHaveTextContent('Agree to the following');
+
+    let necessityIndicator = within(label).getByRole('img');
+    expect(necessityIndicator).toHaveAttribute('aria-label', '(required)');
+
+    let checkboxes = getAllByRole('checkbox');
+    expect(checkboxes[0]).toHaveAttribute('required');
+    expect(checkboxes[1]).toHaveAttribute('required');
+    expect(checkboxes[2]).toHaveAttribute('required');
+  });
+
+  it('does not add aria-invalid to every checkbox by default', () => {
+    let {getAllByRole} = render(
+      <Provider theme={theme}>
+        <CheckboxGroup label="Favorite Pet" validationState="invalid">
+          <Checkbox value="dogs">Dogs</Checkbox>
+          <Checkbox value="cats">Cats</Checkbox>
+          <Checkbox value="dragons">Dragons</Checkbox>
+        </CheckboxGroup>
+      </Provider>
+    );
+
+    let checkboxes = getAllByRole('checkbox');
+    expect(checkboxes[0]).not.toHaveAttribute('aria-invalid');
+    expect(checkboxes[1]).not.toHaveAttribute('aria-invalid');
+    expect(checkboxes[2]).not.toHaveAttribute('aria-invalid');
+  });
+
+  it('supports validationState on individual checkboxes', () => {
+    let {getAllByRole} = render(
+      <Provider theme={theme}>
+        <CheckboxGroup label="Agree to the following">
+          <Checkbox value="terms" validationState="invalid">Terms and conditions</Checkbox>
+          <Checkbox value="cookies" validationState="invalid">Cookies</Checkbox>
+          <Checkbox value="privacy">Privacy policy</Checkbox>
+        </CheckboxGroup>
+      </Provider>
+    );
+
+    let checkboxes = getAllByRole('checkbox');
+    expect(checkboxes[0]).toHaveAttribute('aria-invalid', 'true');
+    expect(checkboxes[1]).toHaveAttribute('aria-invalid', 'true');
+    expect(checkboxes[2]).not.toHaveAttribute('aria-invalid');
+  });
+
+  it.each(['isSelected', 'defaultSelected', 'isEmphasized'])('warns if %s is passed to an individual checkbox', (prop) => {
+    let props = {[prop]: true};
+    let spy = jest.spyOn(console, 'warn').mockImplementation(() => {});
+    render(
+      <Provider theme={theme}>
+        <CheckboxGroup label="Favorite Pet">
+          <Checkbox value="dogs">Dogs</Checkbox>
+          <Checkbox value="cats" {...props}>Cats</Checkbox>
+          <Checkbox value="dragons">Dragons</Checkbox>
+        </CheckboxGroup>
+      </Provider>
+    );
+
+    expect(spy).toHaveBeenCalledWith(`${prop} is unsupported on individual <Checkbox> elements within a <CheckboxGroup>. Please apply these props to the group instead.`);
+  });
+});
diff --git a/packages/@react-spectrum/radio/docs/RadioGroup.mdx b/packages/@react-spectrum/radio/docs/RadioGroup.mdx
index 9394d1e6022..7853d48d43b 100644
--- a/packages/@react-spectrum/radio/docs/RadioGroup.mdx
+++ b/packages/@react-spectrum/radio/docs/RadioGroup.mdx
@@ -111,7 +111,7 @@ Radio elements should always have a visible label.
 
 ### Internationalization
 
-To internationalize a RadioGroup, a localized string should be set as the child content of the Radio.
+To internationalize a RadioGroup, a localized string should be passed to the `label` prop and as the child content of the Radio elements.
 For languages that are read right-to-left (e.g. Hebrew and Arabic), the Radio is automatically placed on the right side of the text. When the necessityIndicator prop is set to "label", a localized string will be provided for "(required)" or "(optional)" automatically.
 
 ## Events
@@ -125,7 +125,7 @@ function Example() {
 
   return (
     <>
-      <RadioGroup label="Favorite avatar" onChange={setSelected}>
+      <RadioGroup label="Favorite avatar" value={selected} onChange={setSelected}>
         <Radio value="wizard">Wizard</Radio>
         <Radio value="dragon">Dragon</Radio>
       </RadioGroup>
diff --git a/packages/@react-stately/checkbox/docs/useCheckboxGroupState.mdx b/packages/@react-stately/checkbox/docs/useCheckboxGroupState.mdx
index 5970788609b..72a88b822d3 100644
--- a/packages/@react-stately/checkbox/docs/useCheckboxGroupState.mdx
+++ b/packages/@react-stately/checkbox/docs/useCheckboxGroupState.mdx
@@ -17,6 +17,7 @@ import packageData from '@react-stately/checkbox/package.json';
 ---
 category: Forms
 keywords: [toggle, checkbox, switch, input, state]
+after_version: 3.1.0
 ---
 
 # useCheckboxGroupState
diff --git a/packages/@react-stately/checkbox/package.json b/packages/@react-stately/checkbox/package.json
index 8e75509bf6f..b8a7d45e419 100644
--- a/packages/@react-stately/checkbox/package.json
+++ b/packages/@react-stately/checkbox/package.json
@@ -2,6 +2,7 @@
   "name": "@react-stately/checkbox",
   "version": "3.1.0",
   "description": "Spectrum UI components in React",
+  "private": true,
   "license": "Apache-2.0",
   "main": "dist/main.js",
   "module": "dist/module.js",
diff --git a/packages/@react-stately/checkbox/src/useCheckboxGroupState.ts b/packages/@react-stately/checkbox/src/useCheckboxGroupState.ts
index 918134e4801..f84c68a5deb 100644
--- a/packages/@react-stately/checkbox/src/useCheckboxGroupState.ts
+++ b/packages/@react-stately/checkbox/src/useCheckboxGroupState.ts
@@ -12,15 +12,20 @@
 
 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[],
 
+  /** Whether the checkbox group is disabled. */
+  readonly isDisabled: boolean,
+
+  /** Whether the checkbox group is read only. */
+  readonly isReadOnly: boolean,
+
+  /** Returns whether the given value is selected. */
+  isSelected(value: string): boolean,
+
   /** Sets the selected values. */
   setValue(value: string[]): void,
 
@@ -34,23 +39,29 @@ export interface CheckboxGroupState {
   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);
+  let [selectedValues, setValue] = useControlledState(props.value, props.defaultValue || [], props.onChange);
 
   const state: CheckboxGroupState = {
-    name,
-    value: selectedValue,
-    setValue,
+    value: selectedValues,
+    setValue(value) {
+      if (props.isReadOnly || props.isDisabled) {
+        return;
+      }
+
+      setValue(value);
+    },
+    isDisabled: props.isDisabled || false,
+    isReadOnly: props.isReadOnly || false,
+    isSelected(value) {
+      return selectedValues.includes(value);
+    },
     addValue(value) {
-      if (props.isReadOnly) {
+      if (props.isReadOnly || props.isDisabled) {
         return;
       }
       setValue(values => {
@@ -61,7 +72,7 @@ export function useCheckboxGroupState(props: CheckboxGroupProps = {}): CheckboxG
       });
     },
     removeValue(value) {
-      if (props.isReadOnly) {
+      if (props.isReadOnly || props.isDisabled) {
         return;
       }
       setValue(values => {
@@ -72,7 +83,7 @@ export function useCheckboxGroupState(props: CheckboxGroupProps = {}): CheckboxG
       });
     },
     toggleValue(value) {
-      if (props.isReadOnly) {
+      if (props.isReadOnly || props.isDisabled) {
         return;
       }
       setValue(values => {
diff --git a/packages/@react-stately/checkbox/test/useCheckboxGroupState.test.tsx b/packages/@react-stately/checkbox/test/useCheckboxGroupState.test.tsx
index 912ee5302d2..d1f42ea58ae 100644
--- a/packages/@react-stately/checkbox/test/useCheckboxGroupState.test.tsx
+++ b/packages/@react-stately/checkbox/test/useCheckboxGroupState.test.tsx
@@ -19,23 +19,36 @@ describe('useCheckboxGroupState', () => {
     function Test() {
       const state = useCheckboxGroupState();
 
-      expect(typeof state.name).toBe('string');
       expect(state.value).toEqual([]);
+      expect(state.isDisabled).toBe(false);
+      expect(state.isReadOnly).toBe(false);
       expect(typeof state.setValue).toBe('function');
       expect(typeof state.addValue).toBe('function');
       expect(typeof state.removeValue).toBe('function');
       expect(typeof state.toggleValue).toBe('function');
+      expect(typeof state.isSelected).toBe('function');
 
       return null;
     }
     render(<Test />);
   });
 
-  it('should return the same `name` that has been provided', () => {
+  it('should return the same `isDisabled` that has been provided', () => {
     function Test() {
-      const state = useCheckboxGroupState({name: 'foo'});
+      const state = useCheckboxGroupState({isDisabled: true});
 
-      expect(state.name).toBe('foo');
+      expect(state.isDisabled).toBe(true);
+
+      return null;
+    }
+    render(<Test />);
+  });
+
+  it('should return the same `isReadOnly` that has been provided', () => {
+    function Test() {
+      const state = useCheckboxGroupState({isReadOnly: true});
+
+      expect(state.isReadOnly).toBe(true);
 
       return null;
     }
@@ -64,6 +77,18 @@ describe('useCheckboxGroupState', () => {
     render(<Test />);
   });
 
+  it('should support isSelected to determine if a value is selected', () => {
+    function Test() {
+      const state = useCheckboxGroupState({value: ['foo', 'bar']});
+
+      expect(state.isSelected('foo')).toBe(true);
+      expect(state.isSelected('baz')).toBe(false);
+
+      return null;
+    }
+    render(<Test />);
+  });
+
   it('should be possible to control the value', () => {
     function Test({value}: {value: string[]}) {
       const state = useCheckboxGroupState({value});
@@ -210,12 +235,59 @@ describe('useCheckboxGroupState', () => {
     let addValue: (value: string) => void;
     let removeValue: (value: string) => void;
     let toggleValue: (value: string) => void;
+    let setValue: (value: string[]) => void;
 
     function Test() {
       const state = useCheckboxGroupState({isReadOnly: true, defaultValue: ['test']});
       addValue = state.addValue;
       removeValue = state.removeValue;
       toggleValue = state.toggleValue;
+      setValue = state.setValue;
+
+      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');
+
+    act(() => {
+      setValue(['foo']);
+    });
+
+    expect(container.textContent).toBe('test');
+  });
+
+  it('should not update state for disabled group', () => {
+    let addValue: (value: string) => void;
+    let removeValue: (value: string) => void;
+    let toggleValue: (value: string) => void;
+    let setValue: (value: string[]) => void;
+
+    function Test() {
+      const state = useCheckboxGroupState({isDisabled: true, defaultValue: ['test']});
+      addValue = state.addValue;
+      removeValue = state.removeValue;
+      toggleValue = state.toggleValue;
+      setValue = state.setValue;
 
       return <>{state.value.join(', ')}</>;
     }
@@ -241,5 +313,11 @@ describe('useCheckboxGroupState', () => {
     });
 
     expect(container.textContent).toBe('test');
+
+    act(() => {
+      setValue(['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 92253e59063..ac79c4d352e 100644
--- a/packages/@react-types/checkbox/src/index.d.ts
+++ b/packages/@react-types/checkbox/src/index.d.ts
@@ -18,11 +18,13 @@ import {
   FocusableProps,
   InputBase,
   LabelableProps,
+  Orientation,
+  SpectrumLabelableProps,
   StyleProps,
   Validation,
   ValueBase
 } from '@react-types/shared';
-import {ReactNode} from 'react';
+import {ReactElement, ReactNode} from 'react';
 
 export interface ToggleProps extends InputBase, Validation, FocusableProps {
   /**
@@ -58,12 +60,7 @@ 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 CheckboxGroupProps extends ValueBase<string[]>, InputBase, LabelableProps {}
 
 export interface CheckboxProps extends ToggleProps {
   /**
@@ -75,7 +72,12 @@ export interface CheckboxProps extends ToggleProps {
 
 export interface AriaCheckboxProps extends CheckboxProps, AriaToggleProps {}
 
-export interface AriaCheckboxGroupProps extends CheckboxGroupProps, DOMProps, AriaLabelingProps, AriaValidationProps {}
+export interface AriaCheckboxGroupProps extends CheckboxGroupProps, DOMProps, AriaLabelingProps, AriaValidationProps {
+  /**
+   * The name of the CheckboxGroup, used when submitting an HTML form.
+   */
+  name?: string
+}
 
 export interface AriaCheckboxGroupItemProps extends Omit<AriaCheckboxProps, 'isSelected' | 'defaultSelected'> {}
 
@@ -85,3 +87,20 @@ export interface SpectrumCheckboxProps extends AriaCheckboxProps, StyleProps {
    */
   isEmphasized?: boolean
 }
+
+export interface SpectrumCheckboxGroupProps extends AriaCheckboxGroupProps, SpectrumLabelableProps, Validation, StyleProps {
+  /**
+   * The Checkboxes contained within the CheckboxGroup.
+   */
+  children: ReactElement<CheckboxProps> | ReactElement<CheckboxProps>[],
+  /**
+   * The axis the checkboxes should align with.
+   * @default 'vertical'
+   */
+  orientation?: Orientation,
+  /**
+   * By default, checkboxes are not emphasized (gray).
+   * The emphasized (blue) version provides visual prominence.
+   */
+  isEmphasized?: boolean
+}
diff --git a/packages/dev/parcel-packager-docs/DocsPackager.js b/packages/dev/parcel-packager-docs/DocsPackager.js
index 8275083b6f8..4e91afbf6a6 100644
--- a/packages/dev/parcel-packager-docs/DocsPackager.js
+++ b/packages/dev/parcel-packager-docs/DocsPackager.js
@@ -114,6 +114,10 @@ module.exports = new Packager({
           }
         }
 
+        if (t && t.type === 'identifier' && t.name === 'Omit' && application) {
+          return omit(application[0], application[1]);
+        }
+
         if (t && t.type === 'identifier' && params && params[t.name]) {
           return params[t.name];
         }
@@ -264,3 +268,36 @@ function merge(a, b) {
     }
   }
 }
+
+function omit(obj, toOmit) {
+  if (obj.type === 'interface' || obj.type === 'object') {
+    let keys = new Set();
+    if (toOmit.type === 'string' && toOmit.value) {
+      keys.add(toOmit.value);
+    } else if (toOmit.type === 'union') {
+      for (let e of toOmit.elements) {
+        if (e.type === 'string' && e.value) {
+          keys.add(e.value);
+        }
+      }
+    }
+
+    if (keys.size === 0) {
+      return obj;
+    }
+
+    let properties = {};
+    for (let key in obj.properties) {
+      if (!keys.has(key)) {
+        properties[key] = obj.properties[key];
+      }
+    }
+
+    return {
+      ...obj,
+      properties
+    };
+  }
+
+  return obj;
+}
diff --git a/scripts/buildWebsite.js b/scripts/buildWebsite.js
index 49f770b7a9f..7a99e3b4795 100644
--- a/scripts/buildWebsite.js
+++ b/scripts/buildWebsite.js
@@ -15,6 +15,7 @@ const fs = require('fs-extra');
 const packageJSON = require('../package.json');
 const path = require('path');
 const glob = require('fast-glob');
+const semver = require('semver');
 const spawn = require('cross-spawn');
 
 build().catch(err => {
@@ -66,7 +67,21 @@ async function build() {
 
       let docsDir = path.join(packagesDir, path.dirname(p), 'docs');
       if (fs.existsSync(docsDir)) {
-        fs.copySync(docsDir, path.join(dir, 'docs', json.name, 'docs'));
+        let contents = fs.readdirSync(docsDir);
+        for (let file of contents) {
+          let docFile = path.join(docsDir, file);
+          let destFile = path.join(dir, 'docs', json.name, 'docs', file);
+          if (file.endsWith('.mdx')) {
+            // Skip mdx files with an after_version key that is <= to the current package version.
+            let contents = fs.readFileSync(docFile, 'utf8');
+            let m = contents.match(/after_version:\s*(.*)/);
+            if (!m || semver.gt(json.version, m[1])) {
+              fs.copySync(docFile, destFile)
+            }
+          } else {
+            fs.copySync(docFile, destFile);
+          }
+        }
       }
     }
   }