Introduction

This course teaches 3D design and digital fabrication using a fully accessible, command-line-driven toolchain centered on OpenSCAD (text-based CAD), 3DMake (non-visual build automation), and accessible editors (VS Code, Notepad++, command-line editors) with screen reader support.

The curriculum is explicitly designed for blind and visually impaired learners who use screen readers (NVDA, JAWS, Orca, VoiceOver). It eliminates GUI navigation and visual feedback in favor of keyboard-driven, text-based workflows that screen readers can fully access. Accessibility is not an add-on. It is the foundation of every tool, workflow, and lesson in this curriculum.

Curriculum Structure

Screen Reader Setup & Accessibility Fundamentals

Before choosing a command-line pathway, students learn to optimize their screen reader setup for terminal work and understand accessibility options.

What’s Included:

• Screen Reader Accessibility Guide - Comprehensive NVDA & JAWS reference with terminal tips for PowerShell, CMD, and Git Bash
• Screen Reader Choice: Windows CLI - Help choosing between NVDA and JAWS
• Braille Display & Terminal Mode - Advanced accessibility setup with refreshable braille displays
• Editor Selection and Setup - Choosing and configuring an accessible text editor

Why start here? Screen reader optimization is the foundation for all command-line work. Students learn keyboard shortcuts, navigation techniques, and terminal-specific accessibility before diving into any CLI pathway.

Command-Line Foundation (Choose Your Path)

Students master terminal/command-line fundamentals before learning 3D design. You choose between three equivalent pathways based on your operating system and learning preferences.

Compare All Three Pathways

Command Line Interface Selection Guide

This guide provides a comprehensive comparison including:

• Feature matrix comparing all three shells
• Command comparison table (navigation, file operations, scripting)
• Learner profiles to help you choose
• Goal-based recommendations
• FAQ addressing common questions

PowerShell Foundation (Recommended for Windows Users)

Where to Start: PowerShell Curriculum Overview

Lessons Included:

• Powershell Lesson Pre: Your First Terminal - Opening PowerShell, first commands, screen reader tricks
• Powershell Lesson 0: Getting Started - Paths, shortcuts, tab completion
• Powershell Lesson 1: Navigation - Moving around the file system confidently
• Powershell Lesson 2: File and Folder Manipulation - Creating, editing, moving files
• Powershell Lesson 3: Input, Output, and Piping - Redirecting output, piping commands
• Powershell Lesson 4: Environment Variables and Aliases - Setting variables, creating shortcuts
• Powershell Lesson 5: Filling in the Gaps - Control flow, profiles, useful tricks
• Powershell Lesson 6: Advanced Terminal Techniques - Scripts, functions, professional workflows
• PowerShell Unit Test & Practice - Comprehensive self-assessment

Time commitment: 30-45 hours (for screen reader users) Best for: Users who want modern Windows features and advanced automation Skills: Terminal navigation, piping, advanced scripting, professional automation

Windows Command Prompt Foundation (Simplified Alternative)

Where to Start: CMD Curriculum Overview

Lessons Included:

• Command Line Lesson Pre: Your First Terminal - Opening CMD, first commands, screen reader tricks
• Command Line Lesson 0: Getting Started - Paths, shortcuts, command basics
• Command Line Lesson 1: Navigation - Moving around the file system confidently
• Command Line Lesson 2: File and Folder Manipulation - Creating, editing, moving files
• Command Line Lesson 3: Input, Output & Redirection - Redirecting output, piping commands
• Command Line Lesson 4: Environment Variables & Shortcuts - Setting variables, shortcuts
• Command Line Lesson 5: Filling in the Gaps - Batch files, advanced techniques
• Command Line Lesson 6: Advanced Terminal Techniques - Scripts, automation, professional workflows
• CMD Unit Test & Practice - Comprehensive self-assessment

Time commitment: 30-45 hours (for screen reader users) Best for: Absolute beginners or users who prefer simplicity Skills: Terminal navigation, file operations, batch scripting, basic automation

Git Bash Foundation (Cross-Platform Skills)

Where to Start: Git Bash Curriculum Overview

Introductory & Reference Materials:

Lessons Included:

• Bash Lesson Pre: Your First Terminal - Opening Git Bash, first commands, screen reader tricks
• Bash Lesson 0: Getting Started - Paths, shortcuts, Unix path notation
• Bash Lesson 1: Navigation - Moving around the file system confidently
• Bash Lesson 2: File and Folder Manipulation - Creating, editing, moving files
• Bash Lesson 3: Input, Output & Piping - Redirecting output, piping commands
• Bash Lesson 4: Environment Variables & Aliases - Setting variables, creating shortcuts
• Bash Lesson 5: Filling in the Gaps - Shell profiles, history, debugging
• Bash Lesson 6: Advanced Terminal Techniques - Scripts, functions, professional workflows
• GitBash Unit Test & Practice - Comprehensive self-assessment

Time commitment: 30-45 hours (for screen reader users) Best for: Users who want cross-platform skills (Windows, macOS, Linux) Skills: Unix/bash commands, shell scripting, cross-platform automation

Important

Choose ONE pathway and complete it fully. All three teach identical fundamental concepts using different tools. Each integrates fully with 3D design workflows.

3dMake Foundation & Design (11 Lessons + 6 Appendices)

Where to Start: 3dMake Introduction

Students build parametric 3D designs using OpenSCAD and automate the workflow with 3DMake.

Main Curriculum: 11 Progressive Lessons

Total: 45-55 hours instruction + practice projects

Reference Appendices

Command Line Tools:

• Appendix A: Command Line (CMD/Batch) Integration for SCAD Workflows - Batch processing and automation for CMD users
• Appendix B: PowerShell Integration for SCAD Workflows - Batch processing, automation scripts, and advanced workflow integration for PowerShell users
• Appendix C: Git Bash / POSIX Shell Integration for SCAD Workflows - Shell scripting and automation for Git Bash / Unix shell users

3dMake:

• 3DMake CLI Cheat Sheet - Quick reference for 3dm command-line tool
• Appendix A: Comprehensive Slicing Guide - Complete reference for PrusaSlicer, Bambu Studio, Cura, and OrcaSlicer configuration
• Appendix B: Material Properties & Selection Guide - Detailed material reference including shrinkage data, print settings, and properties
• Appendix C: Tolerance Testing & Quality Assurance Matrix - Comprehensive QA procedures and tolerance validation methods
• Appendix D: Advanced OpenSCAD Concepts - Specialized topics including gears, batch processing, performance, print orientation, and recursion
• 3dMake Code Examples & Assets - OpenSCAD code examples and reference designs

The Accessible Toolchain

Screen Reader Compatibility Throughout

This course uses tools designed for screen reader access:

• Terminal/Command line - Text-based, fully accessible to NVDA, JAWS, Orca, VoiceOver
• OpenSCAD - Free, open-source text-based CAD (no visual-only GUI dependency)
• 3DMake - Command-line build tool eliminating GUI navigation
• Accessible text editors - Notepad, VS Code, Notepad++, Nano, Vim, etc. (all keyboard-driven, screen reader friendly)

See Appendix A: 3DMake Cheat Sheet for detailed keyboard shortcuts and configuration.

3DMake: Non-Visual Build Automation

3DMake makes the entire design-to-print pipeline accessible:

3dm build        -> Compiles main.scad to main.stl
3dm info         -> Validates geometry and runs diagnostics
3dm slice        -> Prepares model for printing

• No GUI navigation needed
• Automation eliminates repetitive manual steps
• Configuration files store parameters as human-readable text
• Error reporting is text-based (screen reader accessible)
• Works with command-line slicers

Iterative, Non-Visual Design

Students learn to design through code and testing, not visual previews:

• Write parametric OpenSCAD code in accessible editors
• Run 3dm build to compile to printable file
• Use measurement-based verification (calipers, scales, functional testing)
• Iterate by editing parameters and rebuilding
• No reliance on 3D preview or visual feedback

Project-Based Learning

3dMake lessons include hands-on projects:

• Lesson 6: Keychain with embossed text (3dm commands)
• Lesson 7: Phone stand (parametric transforms)
• Lesson 8: Stackable bins (interlocking features, tolerances)
• Lesson 9: Build automation (PowerShell batch processing)
• Lesson 10: QA testing + accessibility audit (measurement, troubleshooting)
• Lesson 11: Beaded jewelry holder (stakeholder-driven design)

Each project requires:

• Parametric OpenSCAD code (clean, well-commented)
• Functional prototype (tested, iterated)
• Complete documentation (reflections, measurements, decisions)

Learning Support

Primary Navigation & Overview

Curriculum Guide - Detailed overview of all lessons and appendices
Quick Reference - At-a-glance command and syntax reference
mdBook Navigation Guide - How to navigate this curriculum

Setup & Configuration Guides

3dMake Setup Guide - Installation walkthrough
VSCode Setup Guide - Accessibility configuration
Screen Reader Coding Tips (NVDA & JAWS) - Keyboard shortcuts and coding configuration

Quick Reference Materials

OpenSCAD Cheat Sheet - Syntax quick-reference
3DMake CLI Cheat Sheet - Complete 3dm command reference
Filament Comparison Table - Material selection guide
Master Rubric - Project assessment criteria

Safety & Maintenance

Safety Checklist - Pre-print safety procedures
Maintenance Log - Printer maintenance tracking

Troubleshooting & Diagnostics

Common Issues and Solutions - Comprehensive troubleshooting guide
Diagnostic Checklist - Systematic problem diagnosis
Technical Reference - Advanced systems architecture and professional reference

Glossaries & Terminology

Student Glossary - Complete terminology reference for OpenSCAD, 3dMake, 3D Printing, and CLI
Teacher Glossary - Pedagogical framework and instructional design terminology

Command Line Integration Appendices

CLI Appendices Overview - All command line integration guides
Appendix A: CMD/Batch Integration - Windows CMD automation
Appendix B: PowerShell Integration - PowerShell workflow automation
Appendix C: Git Bash Integration - Unix shell integration

3dMake & OpenSCAD Appendices

3dMake Appendices Overview - All 3dMake reference materials
Appendix A: Comprehensive Slicing Guide - PrusaSlicer, Bambu Studio, Cura, OrcaSlicer
Appendix B: Material Properties & Selection Guide - Detailed material specifications
Appendix C: Tolerance Testing & QA Matrix - Quality assurance procedures
Appendix D: Advanced OpenSCAD Concepts - Gears, recursion, performance optimization

Code Examples & Assets

3dMake Code Examples & Assets - OpenSCAD code examples and reference designs

Further Reading & References

References & Further Reading - Peer-reviewed research and scholarly works

Supplemental Resources & Textbooks

Textbook Options

Beginner-Friendly Textbooks:

• Programming with OpenSCAD: A Beginner’s Guide to Coding 3D-Printable Objects by Justin Gohde and Marius Kintel - Comprehensive reference covering OpenSCAD syntax, geometry concepts, and design patterns. Ideal for deep dives into specific topics and as a reference guide throughout the course. Available in EPUB format (screen reader accessible).
• Simplifying 3D Printing with OpenSCAD by Alicia Noors - Focused on practical workflows, optimization, and real-world printing scenarios. Available in EPUB/PDF formats.
• OpenSCAD for 3D Printing by Al Williams - Hands-on introduction to OpenSCAD with practical 3D printing projects. Covers basics through intermediate topics with step-by-step tutorials.
• Mastering OpenSCAD by Jochen Kerdels - Project-based learning approach with emphasis on parametric design and reusable code modules.

Free Online Resources:

• Official OpenSCAD Documentation - Complete language reference and user manual on Wikibooks. Fully accessible and searchable.
• OpenSCAD Tutorial - Official beginner tutorial covering core concepts and syntax.
• OpenSCAD Cheat Sheet (Official) - Quick reference for all OpenSCAD commands and functions.

Companion Teaching Resources

Curriculum-Specific Materials:

Practice Worksheets - Printable worksheets for visualization practice, decomposition exercises, vocabulary building, and assessment.
Visual Quick Reference - Command syntax guides and geometry reference.
Code Solutions Repository - Working OpenSCAD examples organized by topic (3D shapes, transformations, loops, modules, if-statements, advanced techniques).

Community Resources:

• Thingiverse OpenSCAD Designs - Community-created parametric designs with source code available for study and modification.
• OpenSCAD Forums - Active community support for troubleshooting and learning.
• OpenSCAD Tutorials (YouTube) - Video tutorials (note: supplemental to text-based curriculum; transcripts recommended for accessibility).

Getting Started

For Students

Step 1: Screen Reader Setup & Accessibility

Before beginning any technical work, optimize your screen reader configuration for command-line and coding work:

• Start with Screen Reader Accessibility Guide - Configure NVDA/JAWS for terminal work
• Review Screen Reader Choice: Windows CLI - Help choosing between NVDA and JAWS
• Optional: Braille Display & Terminal Mode - Refreshable braille display configuration
• Complete Editor Selection and Setup - Choose and configure an accessible text editor

Step 2: Choose Your Command Line Pathway

Read Command Line Interface Selection Guide to compare all three CLI options, then select ONE pathway:

• PowerShell Curriculum Overview - Recommended for Windows users
• CMD Curriculum Overview - Simplified alternative for beginners
• Git Bash Curriculum Overview - Cross-platform Unix skills

Complete ALL lessons in your chosen pathway (Pre through Lesson 6 + Unit Test) before moving to Step 3.

Step 3: Begin 3dMake Foundation

Once you’ve completed your CLI foundation:

1. Read 3dMake Introduction - Overview of OpenSCAD and 3dMake
2. Start Lesson 1: Environmental Configuration - Install OpenSCAD and 3dMake
3. Progress through Lessons 2-11 sequentially
4. Complete all project templates as you encounter them
5. Review 3dMake Foundation Curriculum Guide for detailed lesson descriptions

Step 4: Projects & Documentation

Use the Student Templates for all project documentation:

• Your First Print (Lesson 1)
• Your Second Print & Bonus Print (Lesson 2)
• Dice Dice Dice (Lesson 4)
• Parametric Keychain (Lesson 6)
• Miniature Assembly (Lesson 7)
• Snap Fit Clip (Lesson 8)
• Accessibility Audit (Lesson 10)
• Projects 0, 1, and 3 (Lesson 11)

Step 5: Final Assessment

Complete 3dMake Foundation Final Exam to demonstrate mastery of OpenSCAD, 3DMake, and parametric design principles.

For Instructors

Course Setup & Planning:

1. Review Syllabus - Complete course structure, philosophy, learning objectives, and assessment framework
2. Read 3dMake Foundation Curriculum Guide - Detailed lesson-by-lesson breakdown with timing and objectives
3. Study Master Rubric - Comprehensive project assessment criteria
4. Explore Teacher Glossary - Pedagogical framework and instructional terminology

Assessment Materials:

Use the Teacher Templates for grading and feedback:

• your_first_print_teacher_template.md
• your_second_print_teacher_template.md
• bonus_print_teacher_template.md
• dice_dice_dice_teacher_template.md
• parametric_keychain_teacher_template.md
• miniature_assembly_teacher_template.md
• snap_fit_clip_teacher_template.md
• accessibility_audit_teacher_template.md
• project_0_teacher_template.md
• project_1_teacher_template.md
• project_3_teacher_template.md

Final Exam:

Administer 3dMake Foundation Final Exam - 25-question comprehensive assessment covering error detection, code analysis, design challenges, and real-world application (100 points total).

Accessibility Support:

• Ensure all students complete Screen Reader Setup before beginning coursework
• Reference Screen Reader Coding Tips (NVDA & JAWS) for troubleshooting student screen reader issues
• Provide access to Student Glossary for terminology reference

Additional Resources:

• Technical Reference - Advanced troubleshooting and systems architecture
• Further Reading - Peer-reviewed research supporting curriculum design
• Quick Reference - At-a-glance lesson and command reference for student handouts

Screen Readers

We know that users of this curriculum will primarily be JAWS and NVDA screenreader users, or else users of Orca if on a Linux-based system. Dolphin SuperNova (commercial) and Windows Narrator (built-in) are also supported; the workflows and recommendations in this document apply to them. See https://yourdolphin.com/ScreenReader-Training and https://support.microsoft.com/en-us/windows/complete-guide-to-narrator-e4397a0d-ef4f-b386-d8ae-c172f109bdb1 for vendor documentation.

3D Design & Printing Curriculum - Non-Visual Toolchain Edition

Author: Michael Ryan Hunsaker, M.Ed., Ph.D.
Last Updated: 2026-03-04

Overview

This curriculum teaches 3D design and digital fabrication using a fully accessible, command-line-driven toolchain centered on OpenSCAD (text-based CAD), 3DMake (non-visual build automation), and accessible editors (VS Code, Notepad++, command-line editors) with screen reader support. Students progress from foundational command-line skills through guided projects to real-world, stakeholder-driven design challenges.

Who This Course Is For

This course is explicitly designed for blind and visually impaired learners who use screen readers (NVDA, JAWS, Orca, VoiceOver, Windows Narrator, Dolphin SuperNova). It eliminates GUI navigation and visual feedback in favor of keyboard-driven, text-based workflows that screen readers can fully access.

Accessibility is not an add-on. It is the foundation of every tool, workflow, and lesson in this curriculum.

Core Philosophy

1. Text-First Design: All core work happens in text editors and command-line interfaces - no graphical CAD previews, no mouse-dependent menu navigation.

2. Parametric Thinking: Students learn to express geometry as code using OpenSCAD, enabling precise, reproducible, and iterable designs without visual feedback.

3. Automation and Independence: 3DMake automates the journey from code to printed object, handling compilation, slicing orchestration, and metadata management through simple command-line commands and text configuration files.

4. Screen Reader Mastery: Students develop fluency with accessibility technologies (NVDA, JAWS, VoiceOver) and accessible editors, building skills that apply to careers in software, engineering, and digital fabrication.

5. Real-World Impact: Projects culminate in designing assistive-technology solutions for real stakeholders, combining technical skill with human-centered design and documentation.

Curriculum Structure & Scope/Sequence

Setup & Accessibility Fundamentals (Prerequisite - 2-3 hours)

Start here: Screen Reader Accessibility Guide

Before choosing a command-line pathway, students optimize their screen reader setup for terminal work.

Command-Line Foundation (Choose Your Path)

Start here: Command Line Interface Selection Guide

Students master terminal/command-line fundamentals before learning 3D design. Choose one of three equivalent pathways based on your operating system and preferences. All three pathways teach the same concepts and prepare you equally well for 3dMake work.

Important

Choose ONE pathway and complete it fully. All three teach identical fundamental concepts using different tools. Each integrates fully with 3D design workflows.

Pathway A: PowerShell Foundation (Recommended for Windows)

Total Duration: 30-45 hours Start here: PowerShell Curriculum Overview

Outcomes: Terminal fluency, file system mastery, basic scripting, screen reader optimization, automation readiness

Pathway B: Windows Command Prompt (CMD) (Simpler alternative)

Total Duration: 30-45 hours Start here: CMD Curriculum Overview

Outcomes: Terminal fluency, file system mastery, batch scripting, screen reader optimization, automation readiness

Pathway C: Git Bash (Best for macOS/Linux or cross-platform development)

Total Duration: 20-25 hours Start here: Git Bash Curriculum Overview

Outcomes: Terminal fluency, file system mastery, bash scripting, version control basics, automation readiness

Common Outcomes (All Pathways)

• Comfort with terminal/command-line interface
• File system navigation and manipulation
• Basic scripting and automation
• Screen reader optimization for terminal work
• Foundation for 3DMake automation tasks

3dMake Foundation (Main Curriculum - 16-20 hours)

Start here: 3dMake Introduction

11 progressive lessons building from foundational concepts to leadership-level design thinking, organized in 5 parts. Version 2.1 adds comprehensive advanced programming and design topics throughout.

Foundations (Lessons 1-3 | ~4-5 hours)

Verification & Safety (Lessons 4-5 | ~2 hours)

Applied Projects (Lessons 6-8 | ~5-6 hours)

Advanced Topics (Lessons 9-10 | ~3-4 hours)

Leadership (Lesson 11 | ~2 hours)

Total: 16-20 hours of instruction + projects

Reference Appendices

Overview Documents

• CLI Appendices Overview - Summary of all command line integration guides
• 3dMake Appendices Overview - Summary of all 3dMake reference materials

Command Line Integration Appendices

Located in Command_Line_Interface_Selection/:

3dMake & OpenSCAD Appendices

Located in 3dMake_Foundation/:

Project Templates & Assessment Materials

Student Project Templates

Located in 3dMake_Foundation/Templates/Student/, these templates guide students through structured documentation for each project:

• your_first_print_student_template.md - Lesson 1 extension project
• your_second_print_student_template.md - Lesson 2 basic parametric design
• bonus_print_student_template.md - Lesson 2 advanced practice
• dice_dice_dice_student_template.md - Lesson 4 verification project
• parametric_keychain_student_template.md - Lesson 6 practical 3dm commands
• miniature_assembly_student_template.md - Lesson 7 transforms project
• snap_fit_clip_student_template.md - Lesson 8 assembly design
• accessibility_audit_student_template.md - Lesson 10 QA testing
• project_0_student_template.md - Lesson 11 preliminary design
• project_1_student_template.md - Lesson 11 prototype iteration
• project_3_student_template.md - Lesson 11 final stakeholder project

Each template includes sections for problem statement, design decisions, code documentation, testing results, measurements, reflections, and iteration notes.

Teacher Assessment Templates

Located in 3dMake_Foundation/Templates/Teacher/, corresponding templates provide grading rubrics and feedback frameworks:

• your_first_print_teacher_template.md
• your_second_print_teacher_template.md
• bonus_print_teacher_template.md
• dice_dice_dice_teacher_template.md
• parametric_keychain_teacher_template.md
• miniature_assembly_teacher_template.md
• snap_fit_clip_teacher_template.md
• accessibility_audit_teacher_template.md
• project_0_teacher_template.md
• project_1_teacher_template.md
• project_3_teacher_template.md

Each teacher template includes the 0-9 rubric scoring guide, common issues to watch for, and focus areas for feedback.

Final Assessment

3dMake Foundation Final Exam - Comprehensive 25-question assessment (100 points total) covering:

• Section 1: Error Detection & Code Analysis (Problems 1-10)
• Section 2: Design Challenges & Real-World Application (Problems 11-25)

Questions include error identification, code explanation, behavioral analysis, and design problem-solving.

Master Rubric

Master Rubric - Unified assessment framework used across all projects, providing detailed criteria for the three scoring categories (Problem & Solution, Design & Code Quality, Documentation).

Reference Materials for Students & Teachers

Glossaries

• Student Glossary - Complete terminology reference for OpenSCAD, 3dMake, 3D Printing, and CLI
• Teacher Glossary - Pedagogical framework, instructional design strategies, assessment concepts, and accessibility terminology

Technical References

• Technical Reference & Troubleshooting - Advanced systems architecture, OpenSCAD professional modeling reference, 3DMake professional usage, CLI references (CMD, PowerShell, Git Bash), and comprehensive troubleshooting compendium
• Further Reading & References - Peer-reviewed research and scholarly works supporting curriculum design

Quick References

• 3dMake Foundation Curriculum Guide - Detailed lesson-by-lesson breakdown with objectives and timing
• 3dMake Quick Reference - At-a-glance command and syntax reference

Learning Progression: Student Roles

Students move through roles across the curriculum:

The Accessible Toolchain: How It Works

OpenSCAD - Text-Based 3D Design

OpenSCAD is a free, open-source CAD tool that uses a programming language to describe 3D geometry. Students write code that defines shapes, transforms them, and combines them using Boolean operations.

Why OpenSCAD?

• Screen reader friendly: All work happens in a text editor; no visual-only 3D preview.
• Repeatable: Code is version-controlled, documented, and shareable.
• Parametric: Variables allow students to design once and generate variations by changing numbers.
• No visual dependency: Students reason about geometry through code structure and testing.

3DMake - The Non-Visual Build Bridge

3DMake is a command-line tool that automates the journey from OpenSCAD code to a printable file:

3dm build
3dm info
3dm slice

Why 3DMake?

• No GUI navigation: All interaction is keyboard-driven and text-based.
• Automation: Eliminates repetitive manual steps.
• Metadata tracking: Configuration files store parameters as human-readable text.
• Error reporting: Diagnostic output is text that screen readers can read aloud.

Accessible Editors

Students write OpenSCAD code using screen reader-accessible editors:

• VS Code (Windows, macOS, Linux): Industry-standard with built-in screen reader support
• Notepad++ (Windows): Lightweight, keyboard-driven, excellent screen reader support
• Command-line editors (Nano, Vim, Emacs): Full keyboard control, no mouse needed

Prerequisites by Section

Grading Rubric

All projects are scored on a 0-9 scale across three equally weighted categories (3 points each):

Category 1: Problem & Solution (0-3 points)

Category 2: Design & Code Quality (0-3 points)

OpenSCAD code is central to this course. We evaluate the clarity, structure, and documentation of your code as much as the print quality.

Category 3: Documentation (0-3 points)

Score Interpretation

Resubmission Policy

Students may resubmit any project as many times as they need to improve their score. Resubmissions must include a one-paragraph explanation of what was changed and why. The resubmission score replaces the original score.

Quick Links to Essential Tools & Setup

Core Design Toolchain

OpenSCAD

• OpenSCAD Download - Free, cross-platform CAD (all major OS)
• OpenSCAD Documentation - Official reference
• OpenSCAD Cheat Sheet - Quick syntax reference

3DMake

• 3DMake Documentation & Installation - Command-line build tool for OpenSCAD
• 3DMake CLI Cheat Sheet - Complete command reference
• 3dMake Quick Reference - Command and workflow reference

Editors

• VS Code Download - Free, screen-reader-accessible code editor
• Notepad++ Download - Free, lightweight Windows editor
• Editor Selection and Setup Guide - Accessibility-focused setup guide

Screen Reader & Accessibility

Screen Readers

• NVDA Download - Free, open-source screen reader (Windows)
• JAWS Screen Reader - Commercial screen reader (Windows, macOS)
• Orca Screen Reader - Built-in screen reader for Linux/GNOME desktop
• Windows Narrator - Built-in Windows screen reader
• Dolphin SuperNova - Commercial screen reader (Windows)

Note: This curriculum is designed to work with all major screen readers. The workflows are tested primarily with NVDA and JAWS but apply to all screen readers listed above.

Accessibility Configuration

• Screen Reader Accessibility Guide - Comprehensive terminal accessibility guide
• Screen Reader Coding Tips (NVDA & JAWS) - Keyboard shortcuts and configuration
• VSCode Setup Guide - Accessibility-focused editor configuration
• Git Bash Screen Reader Guide - NVDA and JAWS configuration for Git Bash

Slicing Software

• PrusaSlicer
• Bambu Studio
• Cura
• OrcaSlicer
• Appendix A: Comprehensive Slicing Guide - Detailed setup guides for all major slicers

Supplemental Textbooks & Learning Resources

Beginner-Friendly Textbooks:

• Programming with OpenSCAD: A Beginner’s Guide to Coding 3D-Printable Objects by Justin Gohde and Marius Kintel - Comprehensive reference covering OpenSCAD syntax, geometry concepts, and design patterns. Available in EPUB format (screen reader accessible).
• Simplifying 3D Printing with OpenSCAD by Alicia Noors - Focused on practical workflows, optimization, and real-world printing scenarios. Available in EPUB/PDF formats.
• OpenSCAD for 3D Printing by Al Williams - Hands-on introduction to OpenSCAD with practical 3D printing projects. Covers basics through intermediate topics.
• Mastering OpenSCAD by Jochen Kerdels - Project-based learning approach with emphasis on parametric design and reusable code modules.

Free Online Resources:

• Official OpenSCAD Documentation - Complete language reference and user manual on Wikibooks. Fully accessible and searchable.
• OpenSCAD Tutorial - Official beginner tutorial covering core concepts and syntax.
• OpenSCAD Cheat Sheet (Official) - Quick reference for all OpenSCAD commands and functions.

Curriculum-Specific Resources:

• Programming with OpenSCAD Companion Resources - Practice worksheets for visualization, decomposition exercises, vocabulary building, and assessment.
• Visual Quick Reference - Command syntax guides and geometry reference.
• Code Solutions Repository - Working OpenSCAD examples organized by topic (3D shapes, transformations, loops, modules, if-statements, advanced techniques).

Community Resources:

• Thingiverse OpenSCAD Designs - Community-created parametric designs with source code for study and modification.
• OpenSCAD Forums - Active community support for troubleshooting and learning.
• OpenSCAD Tutorials (YouTube) - Video tutorials (note: supplemental to text-based curriculum; transcripts recommended for accessibility).

Local Resources: Utah Makerspaces & Community Printing

Public Library Make Spaces

Salt Lake City Public Library

• SLC Public Creative Lab - Main Library (Level 1)
  • Hardware: Prusa i3 MK3, LulzBot Taz 5, Elegoo Mars 2 (resin)
  • Pricing: Free for prints under 6 hours; $0.50/hr + material cost otherwise

Salt Lake County Library System

• County Library “Create” Spaces
  • Hardware: Flashforge Adventurer 5M Pro, LulzBot Workhorse, laser cutters
  • Pricing: $0.06 per gram of filament used

Makerspaces & Community Centers

Make Salt Lake

• Location: 663 W 100 S, Salt Lake City, UT 84101
• Website: https://makesaltlake.org/
• Equipment: Full metal shop, CNC machines, large-scale FDM and resin printing

University of Utah Maker Spaces

• Lassonde Studios
• Marriott Library ProtoSpace

Troubleshooting & Getting Help

Quick Reference Materials

Setup & Configuration:

• 3dMake Setup Guide - Installation walkthrough
• VSCode Setup Guide - Accessibility-focused editor configuration
• mdBook Navigation Guide - How to navigate this curriculum

Syntax & Commands:

• OpenSCAD Cheat Sheet - Complete syntax quick-reference
• 3DMake CLI Cheat Sheet - All 3dm commands and options

Materials & Safety:

• Filament Comparison Table - Material selection guide
• Safety Checklist - Pre-print safety procedures
• Maintenance Log - Printer maintenance tracking

When You’re Stuck

For Technical Issues:

1. Check Common Issues and Solutions - Comprehensive troubleshooting guide
2. Review Diagnostic Checklist - Systematic problem diagnosis
3. Consult Technical Reference - Advanced systems architecture and professional reference
4. Post in OpenSCAD Discord or Reddit r/openscad
5. Visit your local makerspace for hands-on support

For Accessibility Support:

• Contact your NVDA/JAWS vendor directly for technical assistance
• Refer to the Screen Reader Accessibility Guide
• Review Screen Reader Coding Tips (NVDA & JAWS)
• Check the Git Bash Screen Reader Guide if using Git Bash

For Design & Concept Questions:

• Review Student Glossary for terminology clarification
• Check project-specific guides in lesson folders
• Consult the Master Rubric for assessment expectations

Setup and Accessibility Fundamentals — Complete Guide

Everything you need to configure an accessible working environment before starting the command-line or 3dMake curriculum. Read these sections in order the first time through; return to individual sections as reference when needed.

Contents

Recommended reading order: Part 1 → Part 2 → Part 3 (if applicable) → Part 4. Parts 3 and 4 can be deferred until you need them.

Part 1: Choosing a Screen Reader for Windows Command-Line Work

Screen readers provide speech output and, where supported, braille output that make text-based interfaces accessible to people who are blind or have low vision. In command-line environments they convert terminal text, prompts, and keyboard navigation into audible or tactile feedback so users can work independently in shells such as Windows Terminal, Command Prompt, PowerShell, and Git Bash.

Choosing a screen reader is a personal decision. There is no single reader that is universally better or worse for every user. Preferences depend on workflow, training, budget, and comfort with customization. Each product has genuine strengths and trade-offs. If possible, try the available options and pick what feels most natural for you.

The Four Screen Readers Covered in This Curriculum

NVDA (NonVisual Desktop Access)

NVDA is a free, open-source screen reader developed by NV Access. It is one of the most widely used screen readers in the world.

Advantages:

• Free to download and use; supported by donations.
• Actively developed with frequent updates.
• Excellent support for Windows terminals (Command Prompt, PowerShell, Windows Terminal, Git Bash).
• Extensible through a rich add-on ecosystem.
• Strong community support, forums, and troubleshooting resources.
• Good braille display support via built-in braille drivers and the BRLTTY/LibLouis library.

Disadvantages:

• Advanced paid support is community-driven rather than available from a commercial vendor helpdesk.
• Some edge-case compatibility differences compared to commercial readers.

Cost: Free (donations welcomed at https://www.nvaccess.org/).

Trial: Not applicable — NVDA is always free.

Download: https://www.nvaccess.org/download/

JAWS (Job Access With Speech)

JAWS is a commercial screen reader developed by Freedom Scientific (part of Vispero). It is one of the most feature-rich and widely deployed screen readers in enterprise and educational settings.

Advantages:

• Mature product with decades of development and broad application compatibility.
• Extensive scripting system allows deep customization for specific applications.
• Vendor-provided paid support, training, and documentation.
• Advanced braille display support and configuration.
• Widely used in workplaces and schools, so shared knowledge base is large.

Disadvantages:

• Commercial product with significant licensing cost.
• JAWS demo mode limits session length to approximately 40 minutes before requiring a computer restart or session reset to continue. This can be disruptive during extended practice sessions.
• Some advanced customization (JAWS scripts) requires a learning curve.

Cost: Commercial. Typical U.S. pricing is several hundred dollars per year for a software maintenance agreement (SMA), or a higher one-time perpetual license fee. Check https://www.freedomscientific.com/products/software/jaws/ for current pricing.

Trial: JAWS offers a time-limited demonstration mode (approximately 40 minutes per session). After the demo period expires, you must restart the computer to continue using JAWS without a license. This applies to the full JAWS installer — there is no separate shorter trial download.

Download: https://www.freedomscientific.com/downloads/jaws/

Windows Narrator

Windows Narrator is Microsoft’s built-in screen reader, included with Windows 10 and Windows 11 at no extra cost. It has improved significantly with recent Windows releases.

Advantages:

• Already installed on every Windows 10 and Windows 11 computer — no download or installation needed.
• No cost.
• Simple to start: press Windows+Ctrl+Enter to toggle Narrator on and off.
• Reasonable support for Windows Terminal, Command Prompt, and PowerShell.
• Integrates tightly with Windows accessibility features.

Disadvantages:

• Fewer customization options than JAWS or NVDA for complex command-line workflows.
• Braille display support exists but is more limited than dedicated screen readers.
• Less powerful for advanced scripting, code editing, or rapid navigation in large terminal outputs.
• Less community documentation for terminal-specific workflows compared to NVDA and JAWS.

Cost: Free (included with Windows).

Trial: Not applicable — Narrator is always available on Windows.

Enable: Settings > Accessibility > Narrator, or press Windows+Ctrl+Enter.

Dolphin SuperNova

Dolphin SuperNova (sometimes referred to as “Dolphin Screen Reader” or simply “SuperNova”) is a commercial product from Dolphin Computer Access. It is available in several editions: Magnifier, Magnifier & Speech, and Screen Reader. The Screen Reader and Magnifier & Speech editions provide full screen reader functionality.

Advantages:

• Commercial product with vendor support, training options, and documentation.
• Offers combined magnification and speech in a single product — useful for users with low vision who benefit from both.
• Good braille display support.
• Works with Windows terminals (Command Prompt, PowerShell, Windows Terminal).
• Full-featured 30-day trial license available for evaluation before purchase.

Disadvantages:

• Commercial licensing cost.
• Less widely used than NVDA or JAWS, so community resources and third-party documentation are more limited.
• Configuration for some terminal workflows may require additional setup.

Cost: Commercial. Pricing varies by edition (Magnifier only, Magnifier & Speech, or Screen Reader). Check https://yourdolphin.com/supernova/ for current pricing. Expect costs broadly similar to other commercial screen readers.

Trial: Dolphin provides a full-featured 30-day trial license. This is more generous than JAWS’s per-session demo and allows uninterrupted evaluation over a full month.

Download: https://yourdolphin.com/supernova/

Choosing Between Them for Command-Line Work

Use this decision guide to narrow your choice:

If budget is the primary constraint:
Start with NVDA or Windows Narrator. Both are free. NVDA is generally more capable and better documented for terminal work. Windows Narrator requires no installation and is a good quick-start option.

If you already own or have access to JAWS or Dolphin through school or work:
Use what you have. Both work well for this curriculum.

If you have low vision (partial sight) in addition to using a screen reader:
Consider Dolphin SuperNova, which combines magnification and speech in one product, or use Windows Magnifier alongside NVDA.

If your organization requires vendor-supported software:
JAWS and Dolphin SuperNova both offer commercial support contracts.

If you are unsure:
Install NVDA (free, no risk) and try a few lessons. You can always switch later, and the terminal commands you learn work identically regardless of which screen reader you use.

Terminal Command Reference by Screen Reader

All four screen readers can perform the same tasks in the terminal. The table below shows the key actions and how to perform them with each reader. Exact key names can vary by keyboard layout and screen reader configuration.

Notes on modifier keys:

• NVDA key is Insert by default; can be changed to CapsLock in NVDA Preferences > Keyboard.
• JAWS key is Insert by default; can be changed to CapsLock in JAWS Settings Center.
• Narrator key is CapsLock or Insert; configurable in Settings > Accessibility > Narrator > Keyboard shortcuts.
• Dolphin key is CapsLock by default; configurable in SuperNova Control Panel > Keyboard.

Important Notes for This Curriculum

1. All four screen readers work with all three shells (CMD, PowerShell, Git Bash) covered in this curriculum. You do not need to change screen readers based on which shell pathway you choose.

2. The best practice for all four screen readers when dealing with long terminal output is to redirect it to a file and open it in Notepad:

   command > output.txt
   notepad output.txt
   

   This works in CMD, PowerShell, and Git Bash, and gives you a stable document that all four screen readers can read comfortably.

3. Braille display users can use a braille display alongside any of these four screen readers. See the Braille Display Setup guide for detailed instructions.

4. The screen reader tips in each lesson of this curriculum are written for NVDA, JAWS, Windows Narrator, and Dolphin SuperNova. If the specific key commands differ from what you hear when practicing, check your screen reader’s documentation for the equivalent command — the underlying concept is always the same.

Additional Resources

Part 2: Screen Reader Accessibility Guide for Command-Line Terminals

Target Users: NVDA, JAWS, Windows Narrator, and Dolphin SuperNova users using PowerShell, CMD, or Git Bash
Last Updated: February 2026

This guide is used throughout the Command-Line Foundation curriculum (PowerShell, CMD, and Git Bash pathways) to help screen reader users navigate and work efficiently with the terminal.

Table of Contents

1. Which Terminal Should I Use?
2. Getting Started with Screen Readers
3. NVDA-Specific Tips
4. JAWS-Specific Tips
5. Windows Narrator-Specific Tips
6. Dolphin SuperNova-Specific Tips
7. General Terminal Accessibility
8. Working with Long Output
9. Keyboard Shortcuts Reference
10. Shell-Specific Differences
11. Troubleshooting

Which Terminal Should I Use?

All three command-line shells (PowerShell, CMD, Git Bash) work well with screen readers. Choose the one that best fits your setup:

Key Point: Choose one pathway and complete it fully. All three teach the same skills and prepare you equally well for 3dMake work. Don’t switch mid-curriculum.

Getting Started with Screen Readers

Which Screen Reader Should I Use?

NVDA, JAWS, Windows Narrator, and Dolphin SuperNova all work with the three shells covered in this curriculum. Here is a brief comparison:

Recommendation: If you are new to screen readers, start with NVDA (free, well-documented, good community support) or Windows Narrator (already on your computer, no installation needed). JAWS and Dolphin SuperNova are excellent choices if you already own a license or your organization provides one.

Before You Start

1. Make sure your screen reader is running before opening your terminal.
2. Open your terminal (PowerShell, CMD, or Git Bash) and let your screen reader read the title and prompt.
3. If you do not hear anything, press Alt+Tab to cycle windows and find your terminal.
4. Use your screen reader’s review/virtual cursor to understand the layout.

NVDA-Specific Tips

NVDA is free and available from https://www.nvaccess.org/

These tips work across all shells: PowerShell, CMD, and Git Bash.

Key Commands for Terminals

Note on NVDA key: On desktop keyboards the NVDA modifier is typically the Insert key. On laptops without a numpad the NVDA key is often CapsLock. You can change this in NVDA Preferences > Keyboard.

Example: Reading Long Output

Scenario: You ran a command and it listed 50 files. You cannot hear them all at once.

Solution with NVDA:

1. After the command finishes, press NVDA+Home to read the current line.
2. Press NVDA+Down Arrow repeatedly to read all output line by line.
3. Or redirect to a file first: command > output.txt, then open with notepad output.txt for more comfortable reading.

NVDA Settings for Terminals

1. Press NVDA+N to open the NVDA menu.
2. Go to Preferences > Settings > Speech.
3. Increase or decrease verbosity to taste.
4. Under Document Formatting, enable “Report indentation” (important for reading code).
5. Under Terminal, enable “Speak typed characters” so you hear each key as you type.

JAWS-Specific Tips

JAWS is a commercial screen reader available from https://www.freedomscientific.com/products/software/jaws/

These tips work across all shells: PowerShell, CMD, and Git Bash.

Key Commands for Terminals

Note on JAWS key: The JAWS modifier is typically Insert on a standard keyboard. On laptops, JAWS can be configured to use CapsLock as the modifier instead.

Example: Reading Long Output

Scenario: You ran a command and saved output to a file.

Solution with JAWS:

1. Open the file in Notepad: notepad file.txt
2. In Notepad, press Insert+Ctrl+Down to hear all content from the top.
3. Use Insert+Down Arrow to read line by line at your own pace.
4. Use Insert+F (JAWS Find) to search for specific text within the file.

JAWS Settings for Terminals

1. Press Insert+F3 to open the JAWS menu.
2. Go to Options > Settings Center (or Utilities > Settings Manager in older versions).
3. Search for “terminal” or “console”.
4. Enable “Announce output” and verify “Speak when program speaks” is on.
5. For indent reporting, search for “Indent” and set to “Tones” or “Tones and Speech”.

Windows Narrator-Specific Tips

Windows Narrator is built into Windows 10 and Windows 11 at no extra cost. Enable it via Settings > Accessibility > Narrator or press Windows+Ctrl+Enter.

These tips work across all shells: PowerShell, CMD, and Git Bash.

Key Commands for Terminals

Note on Narrator key: The Narrator modifier is CapsLock or Insert by default. You can change this in Settings > Accessibility > Narrator > Keyboard shortcuts.

Working with Terminals Using Narrator

Narrator works well in focus mode (the default when a terminal is active). In focus mode, arrow keys move through command history and output rather than triggering Narrator navigation.

Tips:

• After running a command, press Narrator+D to read the current line.
• Use Narrator+R to read all output from the current position.
• For long outputs, always redirect to a file: command > output.txt, then open in Notepad where Narrator’s reading experience is more comfortable.
• In Windows Terminal, enable “Accessible terminal” mode in Windows Terminal settings for better Narrator integration.

Narrator Settings for Terminals

1. Open Settings > Accessibility > Narrator.
2. Under “Change what you hear when typing”, enable “Hear characters as you type”.
3. Under “Change what Narrator reads”, enable “Read hints for controls and buttons”.
4. Set verbosity level to 3 or 4 for a good balance of detail.
5. Under “Choose a Narrator voice”, select a voice you find comfortable for extended use.

Known limitation: Narrator has fewer customization options than JAWS or NVDA for advanced terminal work. If you find Narrator insufficient for complex workflows, consider switching to NVDA (free) or JAWS.

Dolphin SuperNova-Specific Tips

Dolphin SuperNova is a commercial screen reader (with optional magnification) available from https://yourdolphin.com/supernova/

These tips work across all shells: PowerShell, CMD, and Git Bash.

Key Commands for Terminals

Note on Dolphin key: Dolphin SuperNova typically uses Caps Lock as its modifier key (referred to as the “Dolphin key”). This can be changed in SuperNova Control Panel > Keyboard.

Working with Terminals Using Dolphin SuperNova

1. Open SuperNova before opening your terminal application.
2. Dolphin SuperNova automatically tracks focus as you move between the editor, terminal, and file explorer.
3. In the terminal, use the Dolphin key+Numpad Plus (say all) to have the screen read after running a command.
4. For complex output, redirect to a file and open in Notepad: command > output.txt, then notepad output.txt.

Dolphin SuperNova Settings for Terminals

1. Open SuperNova Control Panel (press Caps Lock+SpaceBar, or click the SuperNova icon).
2. Go to Speech > Verbosity and set a comfortable level (3 or 4 recommended for terminal work).
3. Go to Speech > Text Processing > Indentation and enable indentation announcement (important for code).
4. Go to Braille > Settings if you are using a braille display alongside speech.
5. In General > Application Settings, you can set terminal-specific verbosity so SuperNova behaves differently in your terminal versus other programs.

Note: Dolphin SuperNova’s magnification features can be helpful if you have some remaining vision. Terminal text can be magnified while still receiving speech output.

General Terminal Accessibility

Understanding the Terminal Layout

All terminals (PowerShell, CMD, Git Bash) follow the same basic layout:

1. Title bar: Window name (e.g., “Windows PowerShell”, “Command Prompt”, “Git Bash”)
2. Content area: Command history and output
3. Prompt: The area where you type (e.g., PS>, C:\>, $)

Your screen reader reads from top to bottom, but focus is at the prompt (bottom).

Navigation Sequence

When you open any terminal:

1. Your screen reader announces the window title.
2. Then it announces the prompt line.
3. Anything before the prompt is previous output.
4. Anything after the prompt is where new output will appear.

Reading Output Effectively

Strategy 1: Immediate Output (Small Amount)

• Run a command.
• Your screen reader announces output immediately.
• This works well for short outputs (a few lines).

Strategy 2: Large Output (Many Lines)

• Redirect to a file: command > output.txt
• Open the file: notepad output.txt (works in all shells on Windows)
• Read in Notepad — easier and more controllable for all screen readers.

Strategy 3: Filtering Output

• Use filtering commands to reduce output.
• PowerShell: command | Select-String "pattern"
• CMD: command | find "pattern"
• Git Bash: command | grep "pattern"

Working with Long Output

This is one of the most common challenges for screen reader users. Here are proven solutions:

Solution 1: Redirect to a File (Recommended)

command > output.txt
notepad output.txt

Advantages: Easy to navigate at your own pace, works with all screen readers, output does not scroll away, you can save it for later reference.

Solution 2: Use Pagination

command | more

Press Space to see the next page, Q to quit. Note: some screen readers struggle with more; Solution 1 is generally preferred.

Solution 3: Filter Output

# PowerShell
ls | Select-String "\.scad"

# CMD
dir | find ".scad"

# Git Bash
ls -la | grep ".scad"

Solution 4: Count Before Displaying

# PowerShell
(ls).Count

This tells you how many items there are before deciding whether to redirect to a file.

Keyboard Shortcuts Reference

Shell Navigation (Works Regardless of Screen Reader)

Screen Reader Navigation Quick Reference

Shell-Specific Differences

While all three shells work equally well with screen readers, there are differences in commands and syntax:

File Listing and Navigation

Output Redirection

Scripting and Automation

Choose ONE pathway and stick with it. Each curriculum teaches you the concepts using that specific shell’s syntax. The accessibility experience is virtually identical across all four screen readers in all three shells — only the command syntax differs.

Troubleshooting

Problem 1: “I Can’t Hear the Output After Running a Command”

Causes and Solutions:

1. Cursor is not at the prompt — Press End or Ctrl+End to go to the end of text, then use screen reader commands to review.
2. Output scrolled off-screen — Redirect to file: command > output.txt, then notepad output.txt.
3. Screen reader focus is on window title, not content — Press Tab or arrow keys to move into the content area.
4. Large output overwhelming screen reader — Use filtering: command | grep "pattern" (Git Bash), command | find "text" (CMD), or command | Select-String "text" (PowerShell).

Problem 2: “Tab Completion Isn’t Working”

1. You must type at least one character before pressing Tab.
2. The folder or file must exist — run dir (CMD), ls (PowerShell/Git Bash) to check.
3. If multiple matches exist, press Tab again to cycle through them.

Problem 3: “Access Denied or Permission Denied”

1. Close your terminal, right-click it, and choose Run as administrator. Confirm the UAC prompt.
2. If the file is in use by another program, close that program and try again.
3. If the path contains spaces, use quotes: cd "Program Files".

Problem 4: “A Command Runs Forever and Won’t Stop”

Press Ctrl+C to interrupt any running command.

Problem 5: “I Need to Edit My Last Command”

1. Press Up Arrow to recall the previous command.
2. Use Left/Right Arrow keys to move through it.
3. Edit as needed and press Enter to run the modified version.

Problem 6: Screen Reader is Not Announcing Indentation

Proper indent announcement is critical for reading code. Enable it for your screen reader:

• NVDA: NVDA Menu > Preferences > Settings > Document Formatting > enable “Report indentation”, set to “Tones and speech”.
• JAWS: Settings Center > search “Indent” > enable “Announce Indentation”, set mode to “Tones” or “Tones and Speech”.
• Windows Narrator: Settings > Accessibility > Narrator > Advanced Options > enable “Report indentation” (limited options compared to NVDA/JAWS).
• Dolphin SuperNova: SuperNova Control Panel > Speech > Text Processing > Indentation > enable and set preferred announcement style.

Pro Tips for Efficiency

Create Aliases for Frequently Used Commands

PowerShell: Set-Alias -Name ll -Value "Get-ChildItem -Name"
CMD: Create a .bat file in a folder on your PATH.
Git Bash: alias ll='ls -la' (add to ~/.bashrc to make permanent)

Use Command History

All shells support Up/Down Arrow to navigate history. In PowerShell, history shows a numbered list and Invoke-History 5 reruns command number 5. In Git Bash, history and !5 work similarly.

Redirect Everything to Files for Accessibility

If a command produces output, save it:

command > results.txt
notepad results.txt

This is always more accessible than reading from the terminal directly.

Quick Reference Card

EVERY SESSION STARTS WITH:
1. pwd / cd            (where am I?)
2. dir / ls            (what is here?)
3. cd path             (go there)

LONG OUTPUT?
-> command > file.txt
-> notepad file.txt

STUCK?
-> Ctrl+C

WANT TO REPEAT?
-> Up Arrow

NEED HELP?
-> PowerShell:  `Get-Help command-name`
-> CMD:         `help command-name`
-> Git Bash:    `man command-name`

Additional Resources

• NVDA: https://www.nvaccess.org/
• JAWS: https://www.freedomscientific.com/products/software/jaws/
• Windows Narrator: https://support.microsoft.com/narrator
• Dolphin SuperNova: https://yourdolphin.com/supernova/
• PowerShell Docs: https://example.com
• CMD Documentation: https://example.com
• Git Bash / Git for Windows: https://example.com
• Accessibility Best Practices: https://example.com

Part 3: Using a Braille Display with the Curriculum

Many blind and low-vision programmers prefer tactile output alongside or instead of speech. A refreshable braille display presents terminal text as a row (or multiple rows) of braille cells and allows you to read at your own pace, re-read lines without interrupting speech, and work quietly. This page covers how to connect and configure a braille display with each screen reader used in this curriculum.

How a Braille Display Works with a Terminal

A refreshable braille display uses small pins that rise and fall to form braille characters. When connected to a computer and paired with a screen reader, the display shows the line of text where the screen reader’s focus or review cursor is located. You can pan left and right across a long line or press routing buttons to move the screen reader cursor to a specific position.

In a terminal environment:

• The display shows the current command line (what you are typing).
• After running a command, you can use your screen reader’s review cursor and the display’s pan keys to read through the output line by line.
• Routing keys (small buttons above or below each braille cell) let you move the cursor directly to that point in the text — useful for re-running or editing commands from history.

Connecting a Braille Display

USB Connection

1. Plug the display’s USB cable into your computer.
2. Windows will attempt to install drivers automatically. If the display is not recognized, install the vendor’s driver software first (see vendor links at the end of this page).
3. Open your screen reader’s braille settings and select the connected display.

Bluetooth Connection

1. Put the braille display into pairing mode (refer to the device’s quick-start guide).
2. On Windows, go to Settings > Bluetooth & devices > Add a device and pair the display.
3. Once paired, open your screen reader’s braille settings and select the display.

Before Opening the Terminal

Always confirm the display is connected and showing output before opening your terminal. A quick test: open Notepad, type a few words, and verify they appear on the display. This confirms the screen reader is routing output correctly before you add the complexity of a terminal session.

Configuring Each Screen Reader for Braille

NVDA

NVDA includes built-in braille support for a wide range of displays without requiring separate vendor software for many devices.

1. Connect your display via USB or Bluetooth.
2. Open the NVDA menu: press NVDA+N (Insert+N or CapsLock+N depending on your modifier key setting).
3. Go to Preferences > Settings > Braille (or press NVDA+Ctrl+B as a shortcut on some versions).
4. In the “Braille display” dropdown, select your display from the list. NVDA supports automatic detection for many displays — you can also select “Automatic” and let NVDA detect it.
5. Set your preferred braille output table (e.g., Unified English Braille Grade 1 or Grade 2, or your country’s national table).
6. Set “Braille input table” if you want to type commands using the display’s braille keyboard (if equipped).
7. Enable “Show cursor” so you can see the caret position on the display.
8. Click OK and test by moving the cursor in Notepad.

Recommended NVDA braille settings for terminal work:

• Output table: Unified English Braille Grade 1 (uncontracted) is recommended for reading code — contractions in Grade 2 can make code harder to read.
• Cursor shape: Dots 7 and 8 (underline) is a common choice.
• Enable “Word wrap” to avoid cutting words at the display’s edge.

NVDA braille keyboard shortcut reference (while braille display is active):

JAWS

JAWS supports a wide range of braille displays through its built-in braille manager and additional vendor drivers.

1. Connect your display via USB or Bluetooth.
2. Install the vendor’s display driver if required (check the vendor’s website — some displays work without a driver in JAWS, others need one).
3. Open the JAWS menu: press Insert+F3 (or your JAWS key+F3).
4. Go to Options > Basics > Braille or use the JAWS Settings Center and search for “Braille”.
5. In Braille Settings, select your display model from the list.
6. Choose your braille translation table (e.g., English Unified Grade 1 for uncontracted, Grade 2 for contracted).
7. Configure cursor routing so that pressing a routing button on the display moves the JAWS cursor to that position.
8. Test in Notepad before moving to a terminal.

JAWS braille settings for terminal work:

• Use Grade 1 (uncontracted) braille for reading code and terminal output. Grade 2 contractions can make commands and file paths difficult to parse.
• Enable “Show active cursor” in JAWS braille settings.
• In the JAWS Settings Center, look for “Braille for Applications” — you can set different braille behavior for specific applications (e.g., a terminal vs. a word processor).

Accessing braille settings:

• Insert+F3 > Options > Basics > Braille
• Or: Insert+F2 (JAWS Manager) > Settings Center > search “braille”

Windows Narrator

Windows Narrator supports braille output through the Windows braille service (Windows 10 version 1903 and later, and Windows 11).

1. Connect your display via USB or Bluetooth.
2. Install the vendor’s display driver if required.
3. Open Settings > Accessibility > Narrator > Braille (Windows 11) or Settings > Ease of Access > Narrator > Use Braille (Windows 10).
4. Turn on “Install braille” (first-time setup may require downloading the braille translation component — approximately 70 MB).
5. Select your display brand and model from the list.
6. Choose a braille table (Grade 1 recommended for terminal work).
7. Test in Notepad before using in a terminal.

Important Narrator braille notes:

• Narrator’s braille support uses the BRLTTY back-end on Windows, which supports most mainstream displays.
• If your display is not listed, check for a Windows Update or visit the display vendor’s website for a Windows Narrator-compatible driver.
• Narrator’s braille customization is less extensive than NVDA’s or JAWS’s. If you need more control, consider using NVDA (free) for braille-heavy work.
• The braille display showing Narrator output does not change the fact that Narrator’s keyboard commands remain the same — your display shows what Narrator is currently reading.

Dolphin SuperNova

Dolphin SuperNova includes integrated braille support as part of its screen reader editions (SuperNova Magnifier & Speech and SuperNova Screen Reader).

1. Connect your display via USB or Bluetooth.
2. Install the vendor’s driver if required.
3. Open the SuperNova Control Panel: press CapsLock+SpaceBar or click the SuperNova icon in the taskbar.
4. Go to Braille > Display and select your display model from the list.
5. Go to Braille > Translation and select your braille table (Grade 1 / uncontracted recommended for code).
6. Go to Braille > Settings to configure cursor style, word wrap, and other options.
7. Click Apply and test in Notepad.

Dolphin SuperNova braille tips for terminal work:

• SuperNova supports a wide range of displays from Freedom Scientific (Focus), HumanWare (Brailliant, BrailleNote as terminal), HIMS, Optelec, and others.
• Use Grade 1 (uncontracted) braille for terminal and code work.
• SuperNova’s “Braille cursor tracking” setting determines whether the braille display follows the text cursor or the screen review cursor — set this to “Cursor” when working in a terminal.
• Dolphin provides a braille viewer on screen (a visual representation of what is on the braille display) — useful when setting up or troubleshooting.

Using the Braille Display in a Terminal

Once your display is configured, here is how to work in a terminal:

1. Reading the prompt: The display shows your current prompt (e.g., C:\Users\YourName> or PS C:\>). Pan right if the prompt is longer than your display width.
2. Reading output: After running a command, use your screen reader’s review cursor commands (see the Screen Reader Accessibility Guide) to move through the output. The display shows one line at a time and updates as you move.
3. Redirecting long output: For long terminal output, redirect to a file and open in Notepad:

   command > output.txt
   notepad output.txt
   

   In Notepad, you can pan through the braille display comfortably without the output scrolling away.
4. Using routing keys: Press the routing key above a word or character to move your cursor to that position. This is especially useful for editing commands recalled from shell history.

Braille Grade and Code

For all screen readers, use Grade 1 (uncontracted) braille when working in terminals and with code. Contracted braille (Grade 2) uses abbreviations designed for reading prose, and those contractions will make command names, file paths, and code syntax difficult or impossible to read correctly.

Example: In Grade 2, the letters “cd” might be represented as a contraction meaning something other than the Change Directory command. In Grade 1, cd is always shown as the letters c and d.

Notetakers and BrailleNote / BrailleSense Devices

BrailleNote Touch+ (HumanWare) and BrailleSense (HIMS) devices run Android as their primary operating system. They cannot run 3dMake or Windows-based terminal workflows natively. These devices are not supported as standalone authoring environments for this curriculum.

Workaround — using them as braille terminals: Both device families can function as a braille display when connected to a Windows computer via USB or Bluetooth. In that configuration:

• The device acts as a standard refreshable braille display.
• Your Windows screen reader (NVDA, JAWS, Narrator, or SuperNova) drives the output.
• Commands are typed on the Windows keyboard; the BrailleNote/BrailleSense shows the output as braille.

To set this up, refer to your device’s documentation for “Terminal mode” or “PC connection mode” and then follow the screen reader braille configuration steps above for your chosen screen reader.

Multiline Braille Displays

Standard refreshable braille displays show a single line of braille (typically 32, 40, or 80 cells). Multiline displays show several lines simultaneously, which can significantly improve the experience of reading code or terminal output because you can see context above and below the current line.

Examples

Monarch (APH / HumanWare partnership):
A multiline braille device developed by the American Printing House for the Blind (APH) in partnership with HumanWare. It presents multiple lines of braille and supports graphical braille output, making it useful for reviewing blocks of code, diagrams, and structured text. Confirm current driver and screen reader compatibility before purchase.

DotPad (Dot Inc.):
A multiline braille and tactile graphics display. Its multiline capability allows programmers to scan several lines of code or terminal output at once. Useful for reviewing structured output without panning repeatedly. Check current Windows compatibility and screen reader support status.

Graphiti and Graphiti Plus (Orbit Research):
Multiline tactile displays from Orbit Research designed for reading text and tactile graphics. Their expanded line count helps with reading code structure and terminal output. Check current driver support for NVDA, JAWS, Narrator, and SuperNova.

Considerations for Multiline Displays

• Driver and screen reader support: Multiline displays are newer technology and support varies. Confirm that your chosen screen reader (NVDA, JAWS, Narrator, or SuperNova) has a driver for the specific device before purchase.
• Size and portability: Multiline displays are larger and heavier than single-line models. Consider your workspace and whether you need portability.
• Cost: Multiline displays are significantly more expensive than single-line displays. Evaluate whether the workflow benefit justifies the cost for your situation.
• Learning curve: Using a multiline display effectively — navigating across lines, understanding the spatial layout — requires some practice beyond what is needed for single-line displays.

Troubleshooting

Display shows nothing / no braille output:

• Verify the USB or Bluetooth connection and check that the display is powered on.
• In your screen reader’s braille settings, confirm the correct display model is selected.
• Try disconnecting and reconnecting. Restart the screen reader if needed.
• Install or reinstall the vendor’s display driver.

Display shows output but navigation is out of sync:

• Toggle your screen reader’s braille mode off and on (usually in the braille settings).
• Restart the screen reader (not the whole computer) and reopen the terminal.
• Try a different terminal emulator (Windows Terminal, Command Prompt, PowerShell) to see if the issue is terminal-specific.

Display driver not found:

• Go to the vendor’s website (links below) and download the latest driver for your operating system version.
• Some displays require firmware updates to work with newer Windows versions.

Routing keys not moving the cursor:

• In your screen reader’s braille settings, confirm that cursor routing is enabled.
• In NVDA, this is under Preferences > Settings > Braille > enable “Move system cursor when routing review cursor”.
• In JAWS, check the routing settings in the JAWS braille configuration.

Vendor Resources

Connecting a Braille Display: Summary Table

This page gives a practical overview. Always consult your braille display vendor’s documentation and your screen reader’s braille guide for device-specific setup steps and advanced configuration options.

Part 4: Editor Selection and Accessibility Setup Guide

Table of Contents

1. Editor Comparison
2. Editor Setup for 3dMake
3. Screen Reader Indent Announcement Configuration
4. Curriculum-Specific Editor Recommendations

Editor Comparison

Overview Table

Detailed Comparison

Notepad

Advantages:

• Minimal interface with no distractions-excellent for absolute beginners
• Very predictable behavior for screen reader users
• Extremely fast file operations
• No configuration required; works immediately
• Pure text editing with no formatting surprises

Disadvantages:

• No syntax highlighting (OpenSCAD code appears as plain text)
• No keyboard shortcuts for common editing tasks
• Limited undo/redo capabilities compared to modern editors
• No integrated terminal (requires separate command prompt window)
• No way to run 3dm commands directly

Best For: Users who prefer absolute simplicity and want minimal cognitive load during learning phase

Screen Reader Experience: Windows Narrator reads all content clearly; JAWS and NVDA work well with standard keyboard navigation

Notepad++

Advantages:

• Lightweight and fast
• Good syntax highlighting for OpenSCAD code
• Customizable interface with configurable keyboard shortcuts
• Tab management for multiple files
• Better organization than Notepad for managing projects
• Good screen reader support for basic operations

Disadvantages:

• No built-in terminal (requires external command prompt)
• Plugin system is limited compared to VSCode
• Screen reader experience with syntax highlighting features can be inconsistent
• Less extensive keyboard customization than VSCode
• No integrated development environment features

Best For: Users who want a lightweight editor with syntax highlighting but prefer not to use a full IDE

Screen Reader Experience: JAWS and NVDA handle navigation well; Windows Narrator works but may struggle with complex UI elements

Visual Studio Code

Advantages:

• Extensive built-in accessibility features (accessibility inspector, keyboard navigation shortcuts)
• Excellent OpenSCAD extension available (scad-preview)
• Integrated terminal allows running 3dm commands without context switching
• Powerful keyboard shortcut customization
• Rich extension ecosystem for workflow enhancement
• Remote development capabilities
• Native support for multiple projects and workspaces
• Excellent search and find/replace functionality

Disadvantages:

• Steeper learning curve than Notepad or Notepad++
• Requires initial configuration for accessibility
• More resource-intensive than lighter editors
• Built-in terminal can be distracting for some users (alternative: Alt-Tab to standalone terminal)

Best For: Users building comprehensive accessibility workflow and wanting integrated development environment

Screen Reader Experience: Excellent; built specifically with accessibility in mind. NVDA, JAWS, Windows Narrator, and Dolphin all receive high-quality support.

Editor Setup for 3dMake

Setting Default Editor in 3dMake

The 3dMake tool uses your system default text editor. However it can be changed with an edit to the global configuration file by typing this into any terminal.

3dm edit-global-config

You get a file like this in your default text edit program, typically notepad on Windows.

view = "3sil"
model_name = "main"
auto_Start_prints = true
printer_profile = "bambu_labs_X1_carbon"

Add one of the following lines to the end of the file:

editor = "code" for VSCode editor = "notepad" for notepad (already the default) editor = '''C:\Program Files (x86)\Notepad++\notepad++.exe''' for Notepad++ (the triple apostrophes mean you do not have to escape the spaces)

Notepad Setup

Configuration Steps:

1. Open 3dMake-generated .scad files directly:

   • Navigate to your project folder in File Explorer
   • Right-click the .scad file -> “Open with” -> “Notepad”
   • File opens immediately for editing

2. Edit and Save:

   • Make changes to your code
   • Press Ctrl+S to save
   • File updates automatically if 3dMake renders in background

3. Run 3dMake Commands:

   • Save your edits (Ctrl+S)
   • Alt-Tab to Command Prompt or PowerShell window
   • Navigate to project directory: cd C:\path\to\project
   • Run 3dMake command: 3dMake render project.scad

Keyboard Shortcuts:

• Ctrl+H: Find and Replace
• Ctrl+G: Go to Line (newer versions)
• Ctrl+Z: Undo
• Ctrl+Y: Redo

Notepad++ Setup

Installation and Configuration:

1. Download from: https://notepad-plus-plus.org/downloads/

2. Choose: Standard Installer (for automatic system integration)

3. Configure OpenSCAD Language Support:

   • Open Notepad++
   • Language -> User Defined Language -> Import… (if OpenSCAD UDL available)
   • Or manually set syntax highlighting:
     • Language -> OpenSCAD (if available in language menu)
     • Otherwise Language -> C++ (provides similar highlighting)

4. Customize for Accessibility:

   • Settings -> Preferences -> General
   • Check: “Minimize to system tray” (optional)
   • Settings -> Preferences -> MISC.
   • Ensure Word Wrap is set to preference
   • Settings -> Preferences -> Backup
   • Enable regular backups of your work

5. Set as Default Editor (see registry method above)

Recommended Keyboard Shortcuts (User-Defined):

Create custom shortcuts by:

• Settings -> Shortcut Mapper
• Add shortcuts for frequently used actions:
  • Save and Switch to Terminal: Alt+T
  • Copy File Path: Ctrl+Shift+C

Tab Management:

• Open multiple files: Each opens in a separate tab
• Switch between tabs: Ctrl+Tab (next) / Ctrl+Shift+Tab (previous)
• Close tab: Ctrl+W

Running 3dMake Commands:

• Save file with Ctrl+S
• Alt-Tab to standalone terminal or command prompt
• Run: 3dMake render filename.scad

Visual Studio Code Setup

Installation:

1. Download from: https://code.visualstudio.com/ or type winget search VSCode in a terminal and then winget install whichever option you prefer
2. Install: Run installer and follow prompts
3. Launch: Open VSCode

Enable OpenSCAD Support:

1. Open Extensions (Ctrl+Shift+X)
2. Search: “OpenSCAD”
3. Install: “scad-preview” by Antyos
4. Install: “OpenSCAD Syntax Highlighter” (optional, for better syntax highlighting)

Initial Accessibility Configuration:

1. Open Settings: Ctrl+,

2. Search: “accessibility”

3. Enable Key Settings:

   • Accessible View: Toggle ON
   • Screen Reader: Select your screen reader (NVDA, JAWS, Narrator, Dolphin)
   • Keyboard Navigation: Ensure enabled
   • Bracket Pair Guides: Can help with code structure understanding

4. Configure Editor Font:

   • Search: “editor.fontSize”
   • Set to comfortable size (recommend 14-16 for better readability)
   • Search: “editor.fontFamily”
   • Select monospace font (e.g., “Consolas” or “Courier New”)

Set as Default Editor (see registry method above)

VSCode Terminal Options:

Option 1: Using Built-in Terminal (Less Accessible)

1. View -> Terminal (or Ctrl+`)
2. Terminal opens at bottom of VSCode window
3. Run commands: 3dMake render filename.scad
4. Note: Switching focus between editor and terminal requires Tab navigation, which can be cumbersome for screen reader users

Keyboard Navigation:

• Ctrl+` : Toggle terminal visibility
• Ctrl+Shift+` : Create new terminal
• Alt+^/v : Switch between terminals

Option 2: Alt-Tab to Standalone Terminal (RECOMMENDED for Accessibility)

1. Keep Command Prompt/PowerShell open:

   • Open Command Prompt (Win+R, type “cmd”, Enter)
   • Position window or minimize to taskbar
   • Navigate to project directory: cd C:\path\to\project

2. From VSCode, switch terminals:

   • Alt+Tab to Command Prompt
   • Run command: 3dMake render filename.scad
   • Alt+Tab back to VSCode
   • Continue editing

Why This Is More Accessible:

• Screen reader focus switches clearly between two applications
• Terminal output is read without VSCode context interference
• Cleaner context switching for command-line workflows
• Easier to diagnose issues when editor and terminal are separate

Keyboard Shortcuts for Common Tasks:

Project Organization in VSCode:

1. Open Project Folder:

   • File -> Open Folder (Ctrl+K, Ctrl+O)
   • Select your project directory
   • All project files appear in Explorer sidebar

2. File Navigation:

   • Press Ctrl+P for Quick Open
   • Type filename to search and jump to file
   • Press Enter to open

3. Quick Switch Between Files:

   • Ctrl+Tab : Open recent files list
   • Arrow keys to select
   • Enter to open

Screen Reader Indent Announcement Configuration

Proper indent announcement is critical for OpenSCAD development, as indentation indicates code nesting and structure.

NVDA (NonVisual Desktop Access)

Enable Indent Announcement:

1. Open NVDA Menu: Alt+N or right-click NVDA icon
2. Preferences -> Settings (Ctrl+Comma)
3. Document Formatting: Tab to it
4. Check: “Report indentation”
5. In the “Indentation reporting” dropdown: Select “Tones and speech”
6. Tone Description: NVDA will announce indent level as progressively higher tones (or speaking indent amount)
7. Apply: Click OK

Additional Tab Stop Configuration:

1. Preferences -> Settings -> Document Formatting
2. Check: “Report line indentation”
3. This will announce: “Indent level 4” or similar as you navigate code

Testing:

• Open a .scad file with nested code (e.g., difference() { cube(); sphere(); })
• Press Down Arrow to move line by line
• NVDA announces indentation level on each new indented line

Keyboard Control:

• NVDA+3 on Numpad: Cycles indent/outline level reporting

JAWS (Freedom Scientific)

Enable Indent Announcement:

1. Open JAWS Manager: Press JAWSKey+F2 (or right-click JAWS icon)
2. Utilities -> Settings Manager
3. Search: “Indent”
4. Look for setting: “Announce Indentation” or “Report Indentation”
5. Enable: Set to “Tones” or “Tones and Speech”
6. Speech Indent Announcement: Speak indent level
7. Tone Indent Announcement: Pitch increases with indent level

Advanced Configuration (Custom Scripts):

If built-in settings don’t work:

1. JAWSKey+F2 -> Utilities -> Settings Manager
2. Search: “Line Breaks” or “Formatting”
3. Ensure: “Report line indentation” is enabled
4. Set tone adjustment: Higher pitch for deeper indents

Testing:

• Open .scad file with nested code
• Navigate with arrow keys
• JAWS announces indent changes with tones or speech

Keyboard Shortcuts:

• JAWSKey+Alt+I: Toggle indent reporting
• JAWSKey+Alt+Shift+I: Cycle between indent reporting modes (speech/tones/off)

Windows Narrator

Enable Indent Announcement:

1. Open Settings: Win+I
2. Ease of Access -> Narrator
3. Advanced Options: Scroll down
4. Check: “Report indentation”
5. Indentation Reporting: Select “Tones” (less intrusive) or “Speech” (explicit)
6. Apply settings

Narrator Keyboard Shortcuts:

• Narrator+Page Down: Read from current position to end of window
• Narrator+Alt+Arrow Keys: Navigate text
• Narrator+V, I: Customize indentation reporting (in Narrator settings)

Testing:

• Open .scad file
• Use Narrator+Page Down to read through code
• Listen for indent tone changes or announcements

Note: Windows Narrator has fewer customization options than JAWS/NVDA; consider NVDA or JAWS for deeper indent control

Dolphin EasyConverter (Dolphin Screen Reader)

Enable Indent Announcement:

1. Open Dolphin Central: Right-click Dolphin icon or click Dolphin icon in taskbar
2. Utilities -> Settings -> Text Processing
3. Look for: “Indentation” section
4. Enable: “Announce indentation”
5. Mode: Select “Tones”, “Speech”, or “Tones and Speech”
6. Tone Pitch: Configure pitch increase for deeper indents
7. Apply

ECO (Ease of Cursor Operation) Customization:

1. Dolphin Central -> Utilities -> ECO Settings
2. Text Options -> Indentation Reporting
3. Set preferred announcement style

Testing:

• Open .scad file with indented code
• Navigate with arrows
• Dolphin announces indent changes

Keyboard Shortcuts:

• Ctrl+Dolphin+I: Toggle indent reporting on/off
• Ctrl+Dolphin+Shift+I: Cycle indent reporting mode

Curriculum-Specific Editor Recommendations

For Absolute Beginners (Lesson 1-2)

Recommended: Notepad or Notepad++

Rationale:

• Minimal interface reduces cognitive load
• Focus stays on learning OpenSCAD syntax, not editor features
• Keyboard navigation is straightforward
• Screen reader experience is predictable

Setup:

1. Use Notepad or Notepad++ as default editor
2. Configure screen reader indent announcement
3. Keep separate Command Prompt window open for 3dMake commands
4. Alt-Tab workflow between editor and terminal

Workflow Example:

1. Open Command Prompt -> Navigate to project folder
2. Run: 3dMake new myproject
3. Alt+Tab to file explorer, open myproject.scad
4. Notepad++ opens file
5. Edit code
6. Ctrl+S to save
7. Alt+Tab to Command Prompt
8. Run: 3dMake render myproject.scad
9. Check output, return to Notepad++ to refine code

For Intermediate Users (Lesson 3-6)

Recommended: Notepad++ or VSCode

Notepad++:

• Adds project organization without overwhelming complexity
• Tab support for managing multiple files
• Syntax highlighting improves code understanding
• Still lightweight and predictable

VSCode:

• Opens doors to more sophisticated workflows
• Extension system enables advanced features (OpenSCAD preview)
• Keyboard customization becomes valuable
• Terminal integration useful but use Alt-Tab method

Setup Decision Tree:

• Choose Notepad++ if: You prefer simplicity and want to focus on code logic
• Choose VSCode if: You’re ready to invest time learning editor features for long-term benefit

Workflow Example with VSCode:

1. Open VSCode (folder view of project)
2. Press Ctrl+P to open file search
3. Type filename and press Enter to open
4. Edit code with autocomplete
5. Ctrl+H for find/replace across project
6. Ctrl+S to save
7. Alt+Tab to Command Prompt
8. Run: 3dMake render filename.scad
9. Alt+Tab back to VSCode to refine code

For Advanced Users (Lesson 7-11)

Recommended: Visual Studio Code

Rationale:

• Powerful search/replace across large projects
• Extension system enables specialized workflows
• Keyboard customization reaches full potential
• Workspace management for complex projects
• Debugging capabilities aid troubleshooting

Advanced Setup:

1. Create custom keyboard shortcuts:

   • Ctrl+Alt+R: Save and render current file
   • Ctrl+Alt+P: Preview (if using scad-preview extension)

2. Install Additional Extensions:

   • “scad-preview”: Real-time 3D preview
   • “Better Comments”: Categorize comments with colors/tones
   • “Bracket Pair Colorizer”: Visual/tonal bracket matching
   • “GitLens”: Track code changes over time

3. Create Task Runner for Common Commands:

   • Ctrl+Shift+B: Configure build task to run 3dMake
   • Create separate tasks for render, export, etc.

4. Use Workspaces:

   • File -> Save Workspace As…
   • Save project-specific workspace with all settings
   • Reopen same workspace configuration automatically

Advanced Workflow Example:

1. Open VSCode with project workspace
2. Ctrl+Shift+P -> Run Task -> "3dMake Render Current"
3. Renders file and shows output
4. Use scad-preview extension for real-time 3D view
5. Edit code with advanced search/replace
6. Ctrl+Alt+R saves and renders automatically
7. Use version control (Git) for tracking changes

Quick Reference: Editor Comparison for Curriculum

Foundations (Lessons 1-2)

• Primary: Notepad or Notepad++
• Focus: Learn syntax and basic concepts
• Terminal: Standalone Command Prompt (Alt-Tab)

Core Skills (Lessons 3-6)

• Primary: Notepad++ or VSCode
• New Features: Begin using editor syntax highlighting
• Terminal: Standalone (continue Alt-Tab method)
• Skills: File organization, search/replace basics

Advanced Projects (Lessons 7-11)

• Primary: VSCode (strongly recommended)
• Advanced: Use extensions, real-time preview, complex project management
• Terminal: Choose Alt-Tab or built-in based on preference
• Skills: Workspaces, task automation, version control

Troubleshooting Common Issues

Problem: Screen Reader Not Announcing Indent

Solution:

1. Verify indent announcement is enabled in screen reader settings (see above)
2. Test with existing .scad file with clear indentation
3. Try different announcement modes (tones vs. speech)
4. Restart screen reader: Alt+Ctrl+N (NVDA) or app restart (JAWS)

Problem: 3dMake Commands Not Running from VSCode Terminal

Solution:

1. Ensure 3dMake is in your system PATH
2. Use standalone terminal instead (Alt-Tab method) - more reliable
3. In VSCode terminal, manually navigate to correct directory first
4. Verify command syntax: 3dMake render filename.scad

Problem: File Not Saving in Editor

Solution:

1. Verify you pressed Ctrl+S
2. Check file permissions on project folder
3. Try “Save As” instead
4. Ensure filename includes .scad extension

Problem: Syntax Highlighting Not Working

Solution:

1. Verify file has .scad extension
2. In Notepad++: Language menu -> select OpenSCAD or C++
3. In VSCode: Install OpenSCAD extension (search Extensions)
4. Restart editor

Problem: Alt-Tab Not Switching Between Windows

Solution:

1. Ensure Command Prompt is open and minimized (not closed)
2. Press Alt+Tab and hold briefly to see window switcher
3. Use Alt+Tab multiple times if more than 2 windows open
4. Alternatively, click taskbar directly (Alt+Tab usually more accessible)

Next Steps

After completing this setup guide:

1. Choose your editor based on the recommendations for your skill level
2. Configure screen reader indent announcement immediately (critical for code structure understanding)
3. Set editor as default for .scad files
4. Test with a simple file: Create a test project and edit it
5. Practice Alt-Tab workflow before moving to Lesson 1
6. Document your setup in a personal note for reference

You are now ready to begin Lesson 1: Environmental Configuration and Developer Workflow

Additional Resources

• NVDA Documentation: https://www.nvaccess.org/documentation/
• JAWS Documentation: https://www.freedomscientific.com/products/software/jaws/
• VSCode Accessibility: https://code.visualstudio.com/docs/editor/accessibility
• Windows Narrator Guide: https://support.microsoft.com/en-us/help/22798/windows-11-narrator-get-started
• Notepad++ Documentation: https://notepad-plus-plus.org/online-help/

Safety Protocols and the Physical Fabrication Interface

Estimated Time: 90–120 minutes
Course: 3dMake Certification — High School Distance Learning Track

Before You Start

Every lesson so far has been entirely digital: code on a screen, commands in a terminal, virtual geometry. Now we’re moving into the physical world. 3D printers are machines that get very hot, draw substantial electrical current, and produce airborne particles and vapors. This lesson exists because these machines are genuinely safe when you know what you’re doing, and genuinely dangerous when you don’t.

The good news is that 3D printing safety is not complicated. The hazards are well-understood, the mitigations are straightforward, and the incidents that do happen are almost always caused by ignoring simple rules. The goal of this lesson is to make sure you know the rules and understand why they exist — not just as things to memorize for a quiz, but as habits you can apply in any shop or makerspace you ever work in.

Learning Objectives

By the end of this lesson you will be able to:

• Identify and apply the Hierarchy of Controls for 3D printing hazards
• Apply fire, electrical, and fume safety protocols for FDM printing
• Understand filament-specific hazards and safe material handling
• Follow a safe printer startup, monitoring, and shutdown sequence
• Select appropriate filament materials for given projects
• Use pre-flight build scripts to estimate cost before committing to a print
• Design parts that minimize safety risks during printing

Concept 1: The Hierarchy of Controls

Why We Don’t Just “Be Careful”

When it comes to workplace and lab safety, the common advice “just be careful” is the least effective approach available. It relies entirely on individual attention, and attention is inconsistent — everyone gets tired, distracted, or hurried sometimes. Professional safety systems are designed to work even when individual attention lapses.

The Hierarchy of Controls is a framework developed by OSHA (the U.S. Occupational Safety and Health Administration) and adopted worldwide. It ranks safety strategies from most effective to least effective, and it says: apply the most effective strategy you can afford, and layer additional strategies below it.

The five levels, from most to least effective:

1. Elimination — Remove the hazard entirely. If a filament requires a sealed enclosure with active filtration and you’re in an open classroom, the safest choice is simply not to use that filament. If a print requires supports made from difficult material, redesign the print to not need supports. Elimination always wins.

2. Substitution — Replace the hazard with a less dangerous one. Use PLA instead of ABS. Use a PEI spring steel bed instead of a glass bed that can shatter. Substitution keeps the functionality while reducing the risk.

3. Engineering Controls — Build protection into the environment. A fume enclosure with a HEPA + activated carbon filter. Thermal runaway protection in the printer firmware. A smoke detector mounted above the printer. These controls work automatically without relying on human behavior.

4. Administrative Controls — Rules, procedures, and training. The startup checklist, the monitoring schedule, the training program you’re in right now. Administrative controls are less reliable than engineering ones because they depend on people following rules consistently.

5. Personal Protective Equipment (PPE) — Gloves, goggles, respirators. PPE is the last resort — it protects one person, it can fail or be used incorrectly, and it doesn’t actually remove the hazard. Always apply higher-level controls first and use PPE as a supplement.

The key insight: many beginners think that putting on gloves and goggles makes them safe. In the hierarchy, PPE is the weakest protection. Real safety comes from eliminating or substituting hazards, and then engineering the remaining risks away. PPE is what you use when those options aren’t available.

Step 1 — Fire and Electrical Safety

The Golden Rule

Never leave an FDM printer completely unattended during the first layer. Print failures most often happen at the start — the first layer either bonds to the bed or it doesn’t. If it doesn’t bond and nobody is watching, the printer may continue for hours, dragging filament across the bed in a mess called “spaghetti” that can tangle around the print head, cause jams, or — in rare worst cases — create a fire hazard.

Be present and watching for at least the first 15 minutes of every print. For long prints, check in every 30 minutes or set up remote monitoring via OctoPrint or a camera.

Fire Hazards

Fire risk in FDM printing comes from two main sources. First, electrical failure: wiring that cracks from repeated movement, loose connections at terminal blocks, or a faulty temperature sensor that allows the heater to run without limit. Second, filament accumulation: plastic that melts and collects on the hot nozzle can sometimes ignite if the build-up becomes large enough.

Fire safety protocols:

• Keep a Class ABC fire extinguisher within arm’s reach of every printer
• Never run the printer while away from the building
• Keep the print area clear of flammable materials: paper, fabric, solvent containers
• Mount a smoke detector directly above the printer so rising smoke reaches it quickly
• Know where the power switch is before you start — cutting power is the first response to any emergency
• If smoke appears: cut power immediately, do not try to continue the print, and report the incident

Electrical Safety

• Use a surge protector to protect the printer’s control board from voltage spikes
• Inspect all wiring periodically, especially the flexible cable bundle that runs to the heated bed — this bundle flexes with every print and can crack the insulation over time
• Thermal runaway protection must be enabled. This firmware feature monitors the temperature sensor and shuts the heater off if the temperature climbs unexpectedly or the sensor fails. A printer without thermal runaway protection can overheat catastrophically. Never disable this protection. If your printer doesn’t have it, do not use it.
• Never open the power supply enclosure or work on any electrical component while the printer is plugged in. The power supply contains mains voltage (120V or 240V) that can kill.

Step 2 — Fume Safety

Why Fumes Matter

All FDM printing produces some airborne emissions. These fall into two categories: particulates (tiny plastic particles, especially ultrafine particles below 0.1 microns) and VOCs (volatile organic compounds — chemical vapors that off-gas from the hot plastic). Both can affect respiratory health with repeated exposure, and the risk varies significantly by material.

The Safe Choice: PLA

PLA (Polylactic Acid) is the safest classroom filament available. It is made from bio-derived sources (corn starch or sugarcane), prints at relatively low temperatures (190–220°C), produces the lowest emissions of any common FDM material, and is forgiving of settings variations. For any classroom project where the mechanical requirements don’t specifically demand a different material, default to PLA.

What “Good Ventilation” Actually Means

“Good ventilation” means that the air in the room is actively exchanging with outside air. This is not the same as “a window that’s crackable.” Active ventilation means:

• A window open with a fan pulling air through the room, or
• An HVAC system that is running and moving air, not just recirculating internal air

If you’re printing ABS or ASA, room ventilation is not sufficient. You need an enclosure with a filtered exhaust system — a box around the printer with an internal fan that pulls fumes through a HEPA filter (for particles) and an activated carbon filter (for VOCs) before exhausting outside or into a large ventilated space.

Step 3 — Material Selection

Choosing the Right Filament

The right material for a project depends on what the part needs to do and where it will be used. This table gives you a practical guide:

What “Hard” to Print Actually Means

When a material is listed as “hard,” that means it requires one or more of the following: a higher nozzle temperature, a heated enclosure to prevent warping, special bed adhesion (glue stick, hairspray, specialized plates), slower print speeds, or more careful tuning of retraction settings. Starting with a difficult material before you have PLA dialed in is a recipe for frustration and wasted filament.

The practical rule: use PLA until you have a specific reason not to. When you need better heat resistance, try PETG next. ABS and specialty materials come later, with appropriate safety infrastructure.

PLA and Sustainability — A Realistic Picture

PLA is often marketed as “biodegradable” and “eco-friendly.” These claims deserve some scrutiny. PLA is bio-derived — made from fermented plant starch rather than petroleum — which reduces its carbon footprint somewhat compared to petroleum plastics. But PLA only biodegrades under very specific industrial composting conditions (temperatures above 58°C sustained for weeks). It does not break down in a home compost bin or a landfill.

The most sustainable approach to FDM printing is not any particular material — it’s designing durable parts that don’t need to be reprinted, using the minimum infill that meets your mechanical requirements, and avoiding test prints you don’t need (which is exactly why this course emphasizes verification before printing).

Step 4 — Estimating Print Cost Before You Print

Always Estimate First

Sending a model to print without checking the cost is like placing a restaurant order without looking at the price. For short prints of small parts, the filament cost is trivial (often under $0.50). But for large, high-infill parts, it can be several dollars — and more importantly, it represents several hours of printer time that you can’t get back if the part turns out to need revision.

The estimate formula from Lesson 1 applies here:

mass (grams)  = (volume_mm³ ÷ 1000) × filament_density_g_per_cm³
cost ($)      = mass × (spool_price_$ ÷ spool_weight_g)

The preflight scripts below automate this calculation and require you to confirm before proceeding.

Pre-Flight Cost Check Scripts

Linux / macOS (bash):

#!/bin/bash
set -e

3dm build
INFO=$(3dm info)
echo "$INFO"

# Extract volume from 3dm info output
VOLUME=$(echo "$INFO" | grep -oP '(?<=Volume:\s)\d+\.?\d*')
if [ -z "$VOLUME" ]; then
  echo "ERROR: Could not parse volume from 3dm info output"
  exit 1
fi

DENSITY=1.24    # g/cm³ — PLA density (change for other materials)
COST_PER_G=0.02 # $/g  — adjust for your spool price

MASS=$(echo "$VOLUME $DENSITY" | awk '{printf "%.1f", ($1/1000)*$2}')
COST=$(echo "$MASS $COST_PER_G" | awk '{printf "%.2f", $1*$2}')

echo ""
echo "=== PRE-FLIGHT SUMMARY ==="
echo "Volume:   ${VOLUME} mm³"
echo "Mass:     ${MASS} g  (PLA @ ${DENSITY} g/cm³)"
echo "Filament: \$${COST}  (@ \$${COST_PER_G}/g)"
echo ""
echo "Proceed? [y/N]"
read CONFIRM
if [ "$CONFIRM" != "y" ]; then
  echo "Cancelled."
  exit 0
fi
echo "Approved. Send to slicer."

Windows (PowerShell):

3dm build
$info = 3dm info
Write-Host $info

$volumeMatch = $info | Select-String -Pattern "Volume:\s+([\d.]+)"
if (-not $volumeMatch) { Write-Error "Could not parse volume"; exit 1 }
$volume = [double]$volumeMatch.Matches.Groups[1].Value

$density  = 1.24    # PLA
$costPerG = 0.02
$mass     = ($volume / 1000) * $density
$cost     = $mass * $costPerG

Write-Host ""
Write-Host "=== PRE-FLIGHT SUMMARY ==="
Write-Host ("Volume:   {0:F0} mm3" -f $volume)
Write-Host ("Mass:     {0:F1} g  (PLA)" -f $mass)
Write-Host ("`$Filament: {0:F2}" -f $cost)
Write-Host ""
$confirm = Read-Host "Proceed? [y/N]"
if ($confirm -ne "y") { Write-Host "Cancelled."; exit 0 }
Write-Host "Approved. Send to slicer."

Step 5 — The Printer Startup Checklist

Before Every Print Session

Use this checklist before starting any print. It takes about 5 minutes and prevents the most common causes of print failure.

PRINTER STARTUP CHECKLIST
□ Bed level verified (run auto-level, or manually check at all four corners)
□ Build plate clean (wipe with IPA — remove finger oils and dust)
□ Nozzle cleared (cold pull if returning from more than a day idle)
□ Filament loaded and extruding cleanly (run 50mm manual extrude purge)
□ First layer height set correctly (0.2mm gap typical for 0.4mm nozzle)
□ Print fan operational (watch it spin up at the start)
□ Workspace clear of flammable materials
□ You will remain present for the first 15 minutes of the print
□ Power switch is accessible and you know where it is

Why Each Item Matters

Bed leveling is the single most critical setting for successful prints. The first layer needs to be squished gently against the bed — close enough to bond, but not so close that filament can’t flow. A bed that’s 0.1 mm too high or too low can cause every print to fail. Most modern printers have automatic bed leveling (ABL), but you should still understand how it works and check that it’s running correctly.

Clean build plate prevents adhesion failures. Skin oils from touching the plate are invisible but dramatically reduce how well plastic sticks. An isopropyl alcohol (IPA) wipe before every print takes 30 seconds and prevents a common failure mode.

Cold pull (nozzle clearing) removes degraded filament from inside the nozzle. Heat the nozzle to print temperature, push some filament through, then let it cool to about 90°C and pull the filament out firmly. The end of the pulled filament should bring out any debris or degraded material from inside the hot end.

Filament loaded correctly means the extruder is feeding without clicking or skipping, the filament is straight in the Bowden tube (if present), and the purge line at the start of the print flows smoothly with no bubbles or gaps.

Step 6 — Monitoring During Prints

What to Watch For

Checking in periodically during a print takes only a few seconds each time and lets you catch problems early. A problem caught at layer 10 is a minor inconvenience. The same problem discovered at layer 100 means you’ve wasted 90 layers of material and print time.

Spaghetti — when the part lifts off the bed and the nozzle starts dragging filament through the air instead of depositing it in layers. The result looks like a pile of plastic spaghetti. This is the most common failure mode and the most important to catch early. If you see it, pause or cancel the print immediately.

Layer shifts — a horizontal displacement somewhere in the print, where part of the model is offset from the rest. This usually indicates a mechanical problem (belt tension, loose pulley, or a motor missing steps). Cancel the print and diagnose the cause before trying again.

Nozzle clog — the extruder starts making a clicking or ticking sound as the gear slips because material isn’t flowing. Filament may start grinding. Pause the print and clear the clog before restarting.

Stringing — thin wisps of filament connecting different parts of the print. Usually a retraction or temperature setting issue rather than an emergency, but it may require post-processing cleanup.

Smoke — immediate emergency. Cut power. Do not attempt to continue or diagnose while the printer is running. Notify your instructor. Do not restart the printer until the cause has been fully identified and corrected.

Step 7 — Safe Shutdown and Part Removal

The Right Way to End a Print

A print ending doesn’t mean the work is done. Follow these steps after every print:

1. Wait for the nozzle to cool below 50°C before reaching anywhere near the hot end. The nozzle can reach 200°C+ during printing and retains heat for several minutes after shutdown.

2. Wait for the bed to cool below 30°C before removing the part. Parts printed on a hot bed can warp slightly if removed while the bed is still warm. Many PEI-coated beds release parts naturally as they cool — you may not even need tools.

3. Use a spatula or palette knife to gently separate the part from the build plate. Never force parts off with your fingers — the edge of a part against a spring steel bed can cut skin. Apply the spatula at a low angle and use a gentle rocking motion.

4. Store filament in a sealed bag with desiccant. Filament absorbs moisture from the air (this is called hygroscopy), and moisture in filament causes bubbling, popping, and reduced mechanical properties during extrusion. This is especially important for Nylon and PETG. A small silica gel desiccant packet inside a ziplock bag is sufficient for short-term storage.

Concept 2: Design for Printability and Safety

Your Design Choices Affect Safety

The decisions you make in OpenSCAD directly affect how safe and reliable the printing process will be. Good design doesn’t just mean a part that looks right — it means a part that prints reliably without requiring dangerous materials, excessive supports, or heroic printer tuning.

Minimize overhangs. Any geometry that extends more than about 45° from vertical needs supports — temporary scaffolding that the printer adds automatically. Supports increase print time, use more material, often leave rough marks where they’re removed, and increase the risk of print failure due to tangled support material. Good design reorients parts or modifies geometry to eliminate or reduce overhangs.

Maintain minimum wall thickness. For a 0.4 mm nozzle, walls below 0.8 mm (two nozzle widths) may not print reliably. Walls below 1.2 mm (three nozzle widths) are marginal for any kind of structural use. Walls below about 0.8 mm may not appear in the sliced output at all — the slicer simply omits them as too small.

Use the safest material that meets requirements. If PLA is strong enough, use PLA. Don’t introduce PETG, ABS, or specialty materials unless you have a specific reason and the appropriate safety infrastructure.

Encode printability constraints in your code:

// Printability constants — these drive safe design decisions
wall_min     = 1.2;    // mm — minimum wall for 0.4mm nozzle (3× nozzle width)
hole_min_r   = 1.5;    // mm — minimum hole radius for reliable circular holes
clearance    = 0.2;    // mm — fitting clearance between mating faces
overhang_max = 45;     // degrees — maximum overhang without supports

module printable_box(w, d, h, wall=2) {
  // Validate against printability limits
  assert(wall >= wall_min, str("wall (", wall, "mm) must be >= ", wall_min, "mm"));
  assert(w > 2 * wall, "width must be greater than two wall thicknesses");
  assert(d > 2 * wall, "depth must be greater than two wall thicknesses");

  // Open-top box: no overhangs on the inside
  difference() {
    cube([w, d, h]);
    translate([wall, wall, wall])
      cube([w - 2*wall, d - 2*wall, h]);  // open at top — no overhang required
  }
}

printable_box(50, 40, 30);

Exercises

Exercise 5.1: Run 3dm info on your model from Lesson 3. Calculate the material cost in PLA and in PETG (density 1.27 g/cm³). If PLA spools cost $20/kg and PETG spools cost $25/kg, what is the cost difference for your part?

Exercise 5.2: Write a pre-flight script (bash or PowerShell) that builds your model, reports the estimated cost, and requires a y confirmation before proceeding.

Exercise 5.3 (Advanced): Modify the pre-flight script to accept a --material argument (options: pla, petg, abs, tpu) and calculate cost using the correct density for the selected material.

Quiz — Lesson 5 (15 questions)

1. What are the five levels of the Hierarchy of Controls, from most to least effective?
2. Why is Elimination considered the most effective safety control?
3. Which filament requires a dedicated fume enclosure with HEPA + activated carbon filtration and is NOT recommended for open classrooms?
4. At what temperature should you wait before removing a print from the bed?
5. What should you do immediately if you see smoke coming from your 3D printer?
6. Give three reasons why PLA is considered the safest classroom filament.
7. What is the minimum reliable wall thickness for a 0.4 mm nozzle, and why does this minimum exist?
8. What is the purpose of storing filament with desiccant?
9. True or False: It is safe to leave a 3D printer completely unattended for hours once the first layer has printed successfully.
10. What is “spaghetti” in the context of a 3D printing failure, and what causes it?
11. What is thermal runaway protection, and why is it critical that it remain enabled?
12. What are the two types of airborne emissions from FDM printing, and which filaments produce the most hazardous levels of each?
13. Describe one engineering control and one administrative control you could implement in a classroom 3D printing lab.
14. Explain why minimizing overhangs in your design is both a safety consideration and a quality consideration.
15. A student wants to print a car dashboard mount in ABS because it will be in a hot car. The classroom has no fume enclosure. Using the Hierarchy of Controls, what recommendations would you make?

Extension Problems (15)

1. Create a material selection flowchart that guides a user from mechanical requirements to the safest filament that meets them.
2. Conduct a ventilation assessment of your classroom or makerspace. Document air exchange methods, window locations, and any existing filtration.
3. Write a Standard Operating Procedure (SOP) for ABS printing that includes all required safety equipment and ventilation infrastructure.
4. Design and describe a “first layer test tile” — a 100 × 100 × 0.4 mm flat tile — and explain how you’d use it to verify bed leveling.
5. Build a parametric filament storage clip in OpenSCAD: a clip that holds the free end of a filament spool. Parameters: filament diameter, clip width.
6. Research OSHA’s published guidance on VOC exposure in 3D printing environments. Summarize the key recommendations.
7. Compare the Safety Data Sheets (SDS) for PLA and ABS filament from two manufacturers. Document differences in recommended exposure limits and PPE.
8. Design a simple printer enclosure in OpenSCAD: four walls, a front door opening, and a top panel with a circular vent hole. Document the parametric variables.
9. Create a safety poster covering the five most important 3D printing safety rules, organized using the Hierarchy of Controls framework.
10. Write a one-page risk assessment for a new FDM printer being added to a classroom.
11. Design and describe a parametric filament moisture indicator holder: a small box that holds a humidity indicator card inside a resealable filament storage bag.
12. Build a “print monitoring log” template: a paper form with columns for time, nozzle temperature, bed temperature, layer number, visual observations, and action taken.
13. Research the difference between particle emissions and VOC emissions from FDM printing. Which is considered more hazardous at typical classroom distances from the printer?
14. Design a parametric build plate corner protector: a small clip that attaches to the edge of a glass or spring steel build plate to protect it from spatula damage.
15. Write a hypothetical “near-miss incident report” for a fictional 3D printing incident using a standard workplace incident report format (date, location, description, contributing factors, corrective actions).

References and Helpful Resources

• OSHA Hierarchy of Controls — https://www.osha.gov/hierarchy-of-controls / NIOSH — https://www.cdc.gov/niosh/topics/hierarchy/default.html
• UL Research Institutes — 3D Printing Emissions Study — https://www.ul.com/news/ul-research-institutes-releases-3d-printing-emissions-study
• NIOSH Science Blog — Health and Safety Considerations for 3D Printing — https://blogs.cdc.gov/niosh-science-blog/2020/05/14/3d-printing/
• PrusaSlicer Documentation — https://docs.prusa3d.com/en/
• All3DP Filament Types — https://all3dp.com/1/3d-printer-filament-types-3d-printing-3d-filament/
• MatterHackers Filament Compare — https://www.matterhackers.com/3d-printer-filament-compare
• Prusa Research Materials Guide — https://help.prusa3d.com/materials

Supplemental Resources

• 3DMake GitHub Repository — https://github.com/tdeck/3dmake
• OpenSCAD User Manual — https://en.wikibooks.org/wiki/OpenSCAD_User_Manual
• All other reference documents are embedded as appendices below — no separate files needed.

Part 2: Reference Appendices

All supporting documents for Lesson 5 are included below. You do not need to open any additional files.

Appendix A: Safety Checklist for 3D Printing

Complete this checklist before and after each printing session. Print it out and keep a copy at your printer station.

Pre-Print Setup

Work Area

• Desk or table cleared of unnecessary items
• Tripping hazards removed from around the printer
• Adequate ventilation confirmed (window open, fan running, or fume enclosure active)
• Class ABC fire extinguisher within arm’s reach
• Smoke detector mounted above printer is functional

Printer Inspection

• Nozzle is clean — no old filament residue baked on
• Build plate is level (re-level if the printer has been moved or bumped)
• Heated bed temperature sensor is attached and secure
• All cables are secure and none are frayed or cracked — especially the flexible bed cable bundle
• Thermal runaway protection is enabled (check firmware settings if unsure)

Filament Preparation

• Filament spool rotates freely on the holder — no binding or tangling
• Filament path is clear of obstructions from spool to extruder
• Extruder drive gear is clean — not clogged with ground plastic
• Filament is correctly loaded and primed (a few mm of filament extruded before starting)

Environmental Conditions

• Room temperature is adequate (18–25°C ideal — extreme cold slows bed heating; extreme heat can soften PLA)
• No direct drafts from windows or air conditioning blowing on the printer (drafts cause warping and layer splitting)
• Adequate lighting to clearly see the first layer as it prints

During Print

First Layer Monitoring (Do Not Leave)

• Watch the first 2–3 layers without interruption
• Bed adhesion is correct — filament sticks flat, not lifting at corners or curling
• Nozzle temperature is stable at target value
• No unusual sounds (grinding, clicking, popping)

Regular Checks (Every 15–30 Minutes)

• Print is building correctly — no layer shifting, no spaghetti
• Filament is feeding smoothly from the spool
• No grinding or skipping sounds from the extruder
• No warping visible at part edges

Temperature Stability

• Heated bed maintains consistent temperature throughout
• Nozzle temperature does not fluctuate more than ±5°C
• No thermal runaway warnings on the printer display

Stop the Print Immediately If

• The nozzle jams or extrudes unevenly
• Filament stops feeding entirely
• Any burning smell is detected
• Visible layer shifting occurs
• Grinding or skipping sounds from the extruder
• Any unusual chemical or burning odor
• Smoke appears — cut power immediately

Post-Print

Cool Down

• Allow the heated bed to cool naturally for 10–15 minutes before attempting print removal
• Keep hands clear of the nozzle until it reads below 50°C
• Confirm the printer is idle and all temperatures are dropping before touching

Print Removal

• Use a proper spatula or scraper — not fingers or improvised tools
• Remove the print only when the bed has fully cooled (PLA releases easily from PEI beds when cool)
• Inspect the print for sharp edges, support stubs, or layer delamination
• Sand or file sharp edges if the part will be handled

Equipment Cleaning

• Wipe the nozzle with a brass wire brush when cooled to 50°C (never cold — residue must be slightly soft)
• Remove any plastic debris and failed print material from the build plate
• Check the extruder for embedded filament residue
• Clear any visible dust from the electronics area

Workspace Cleanup

• Return all tools to their proper storage location
• Dispose of support material and failed prints in a bin (not on the floor)
• Store filament in a sealed bag with desiccant
• Confirm the workspace is clear and safe for the next user

Hazard Reference Summary

Emergency Actions

• Fire: Unplug immediately. Use a dry chemical (Class ABC) extinguisher — NOT water on electrical fires. Evacuate and call emergency services.
• Burns: Rinse with cool (not cold) running water for 15+ minutes. Seek medical attention for any burn larger than a coin.
• Fume inhalation: Move to fresh air immediately. Seek medical attention if symptoms (headache, dizziness, nausea) persist.

Last Reviewed: __________ Reviewed By: __________

Appendix B: Filament Comparison Table

Quick reference for choosing the right filament. All temperature values are typical ranges — always check the label on your specific spool. The spool always wins over this table.

Side-by-Side Comparison

When to Use Each Material

PLA — Use for:

• Prototypes and test prints
• Classroom projects
• Decorative objects and tactile models
• Anything that won’t be exposed to heat, moisture, or heavy mechanical stress

PLA — Avoid for:

• Objects left in a hot car or direct sun (softens above ~60°C)
• Parts that need to flex or bend without cracking
• High-impact applications

PETG — Use for:

• Functional parts that need to be tougher than PLA
• Parts exposed to mild heat or moisture
• Mechanical components: brackets, clips, mounts
• Food-contact applications (check your specific brand for food-safe certification)

PETG — Avoid for:

• Very fine surface detail (it strings more than PLA)
• Projects where you need the easiest possible first-time print

TPU / Flexible — Use for:

• Wearable objects (wristbands, phone cases, watch straps)
• Bumpers and shock absorbers
• Grips and handles
• Objects that must deform under pressure and return to shape

TPU — Avoid for:

• Fine surface detail
• Printers with Bowden extruders (the flexible filament buckles in the tube — direct drive only)
• Your first few prints while still learning

ABS — Use for:

• High-heat environments (car interiors, near motors)
• Parts requiring post-processing (ABS sands, bonds with acetone vapor, and paints easily)
• Professional or industrial contexts with proper dedicated ventilation

ABS — Avoid for:

• Any classroom without a dedicated sealed fume enclosure and active filtration
• Beginners
• Any print where warping at the edges would be a problem and you have no enclosure

Slicer Profile Quick Reference

Filament Storage

All filament absorbs moisture from the air over time. Wet filament causes: popping or crackling sounds during printing, bubbles in extruded plastic, excessive stringing, and weak or brittle finished parts.

Sources: All3DP Filament Types Guide; MatterHackers Filament Compare; Prusa Research Materials Guide

Appendix C: Material Properties Quick Reference

Essential material data for FDM/FFF printing. Use alongside the Filament Comparison Table for material selection decisions.

Properties at a Glance

Heat Resistance After Printing

This is one of the most common reasons to choose a material other than PLA.

Chemical Resistance

Acetone note: Can be used to smooth ABS surfaces (vapor or liquid application). Also dissolves PLA — keep acetone away from PLA prints and filament spools.

Strength After Printing — Curing Time

Freshly printed parts are not at full strength.

Do not stress-test functional parts immediately after printing. Allow at least 24 hours before load testing.

Storage Conditions

Quick Material Selection Guide

Appendix D: Printer Maintenance Log

Copy this log and keep a printed or digital copy with your printer. Fill in the Printer Information section first, then log every maintenance event and issue as it occurs. A complete log is your best diagnostic tool when problems arise.

Printer Information

Maintenance Schedule

Before each use (Daily)

• Visual inspection — no visible damage, cables intact
• Clean nozzle tip if residue is present
• Verify build plate is level (re-level if printer was moved)
• Confirm filament spool rotates freely with no tangles

Weekly

• Clean extruder drive gear (compressed air or brush out ground plastic)
• Inspect and wipe Z-axis rails and lead screw
• Check all cable connections at the control board
• Test emergency stop / power cut

Monthly

• Full build plate leveling procedure (manual or automatic)
• Clean interior of print chamber
• Inspect heating elements and thermistor connections
• Run a temperature calibration test print

Quarterly (every 3 months)

• Replace nozzle if inner bore shows wear or repeat clogging
• Full mechanical inspection — belt tension, eccentric nuts, frame screws
• Check firmware for updates
• Run a full calibration test print and document results

Maintenance Log

Types: Routine / Repair / Calibration / Cleaning / Part replacement

Issue Tracking Log

Statuses: Open / In progress / Resolved / Monitoring

Parts Replacement Record

Filament Compatibility Notes

Record your tested settings for each material on this specific printer. Published temperature ranges are starting points — your printer may run hotter or cooler than its display indicates.

Troubleshooting Quick Reference

Nozzle Clog

• First response: Cold pull (heat to printing temp, push filament through manually, cool to 90°C, pull sharply)
• Second response: Acupuncture needle or nozzle cleaning filament
• Last resort: Replace nozzle

Bed Adhesion Problems

• Check: Bed level, nozzle height from bed, bed surface condition (clean? worn?)
• Fix by material: PLA → clean PEI with IPA; PETG → apply glue stick; ABS → glue stick + enclosure

Layer Shifting

• Common causes: Belt too loose, motor current too low, print speed too high, X/Y axis obstruction
• Check belt tension first — it’s the most common cause

Extrusion Issues (Under-extrusion)

• Common causes: Partial clog, worn drive gear, incorrect extruder steps/mm, wet filament
• Run a flow rate test: extrude 100 mm and measure actual output

Monthly Performance Summary

Last log entry: __________ Logged by: __________

Command-Line Fundamentals - Choose Your Path

Welcome! Before diving into 3D design with OpenSCAD, you’ll master command-line fundamentals. This page will help you understand what command-line interfaces are and choose the best path for you.

What is a Command-Line Interface (CLI)?

A command-line interface is a text-based way to control your computer by typing commands instead of clicking buttons. It’s like sending written instructions to your computer.

Why learn it?

• Speed: Text commands are often faster than clicking through menus
• Precision: Exact control over what your computer does
• Accessibility: Perfect for screen readers - text is naturally readable
• Automation: Repeat tasks automatically
• 3D Printing: Essential for batch processing models and integrating tools

Real-world example

Instead of:

1. Opening File Explorer (click)
2. Navigating folders (click, click, click)
3. Right-clicking a file (click)
4. Selecting “Copy” (click)
5. Navigating to destination (click, click)
6. Right-clicking (click)
7. Selecting “Paste” (click)

You type: cp myfile.txt backup/ and press Enter. Done.

Three Command-Line Options on Windows

Windows offers three ways to use the command line. All are accessible with screen readers. Here’s how they compare:

Option 1: Windows Command Prompt (CMD)

What it is: The original Windows command-line (1981-present)

Best for: Absolute beginners, maximum simplicity

Pros:

• Simple commands and syntax
• Minimal learning curve
• Easy to understand error messages
• Great for basic file operations
• Perfect entry point to command-line world

Cons:

• Limited advanced features
• Less powerful than alternatives
• No built-in piping (but available)
• Smaller ecosystem

Typical command:

copy myfile.txt backup\

Option 2: PowerShell

What it is: Microsoft’s modern, powerful shell (2006-present)

Best for: Intermediate users, advanced automation

Pros:

• Very powerful for scripting
• Modern syntax and features
• Excellent for 3D printing automation
• Professional workflows
• Large community

Cons:

• Steeper learning curve than CMD
• More complex syntax
• More “wordy” commands
• Overkill for simple tasks

Typical command:

Copy-Item -Path myfile.txt -Destination backup/

Option 3: Git Bash

What it is: A Unix/Linux shell on Windows (runs bash inside Git for Windows)

Best for: Programmers, users familiar with Linux, advanced users

Pros:

• Familiar if you know Linux/Unix
• Powerful piping and text processing
• Consistent with other platforms (macOS, Linux)
• Excellent for advanced workflows
• Industry-standard for developers

Cons:

• Requires Git installation
• Steeper learning curve
• Path syntax is different from native Windows
• Less integrated with Windows system tools
• May be “too much” for beginners

Typical command:

cp myfile.txt backup/

Command Comparison Table

Here’s how common tasks compare across the three options:

Feature Comparison Table

Quick Learner Profile Test

Answer these questions to find your best match:

Question 1: Experience Level

• A: I’ve never used a command line Easier paths better (CMD or PowerShell)
• B: I’ve used terminals before Any path works
• C: I use macOS or Linux Git Bash most natural

Question 2: What matters most?

• A: Simplicity and quick learning Choose CMD
• B: Power and advanced features Choose PowerShell
• C: Consistency across Windows/Mac/Linux Choose Git Bash

Question 3: Future goals

• A: Just need to manage files for 3D printing CMD is fine
• B: Advanced automation and scripting PowerShell recommended
• C: Professional development workflows Git Bash best

Question 4: Your main concern

• A: Don’t want steep learning curve CMD
• B: Want industry-standard skills Git Bash
• C: Want Microsoft’s modern tool PowerShell

Recommendation by Goal

Goal: “I want to learn the basics and get to 3D printing quickly”

Start with CMD (Command Prompt)

• Simplest syntax
• Fastest to get productive
• All core concepts transfer to others
• Can switch later if needed

Start CMD Foundation

Goal: “I want power and professional automation”

Start with PowerShell

• Microsoft’s modern, recommended tool
• Professional-grade capabilities
• Better for complex 3D printing workflows
• Skills are in-demand

Start PowerShell Foundation

Goal: “I want skills that work on Windows, Mac, and Linux”

Start with Git Bash

• Unix/bash skills transfer everywhere
• Great preparation for professional development
• Consistent across all platforms
• Growing standard in 3D printing tools

Start Git Bash Foundation

Can I Switch Paths Later?

Yes, absolutely! All three teach the same fundamental concepts:

• File navigation and organization
• Creating and managing files/folders
• Combining commands for powerful workflows
• Scripting and automation basics

Once you learn one, switching to another is quick. The concepts are identical; only the syntax changes.

Example: If you learn CMD first, then later want PowerShell’s power, you’ll find it easy. The command cd Documents works the same way in all three.

Important: All Are Equally Accessible

Screen readers work perfectly with all three

• Text-based by nature (perfect for NVDA, JAWS)
• No mouse required
• Output is naturally readable
• Keyboard-only workflows

Don’t let accessibility concerns influence your choice. All are fully accessible.

Getting Started: Your Decision

Take a moment and choose:

1. I want the simplest path

Command Prompt Foundation

• Time to first success: ~30 minutes
• Learning curve: Gentlest
• When to upgrade: Once you’re comfortable and want power

2. I want modern, powerful Windows tools

PowerShell Foundation

• Time to first success: ~45 minutes
• Learning curve: Moderate
• Best for: Professional automation, 3D printing workflows

3. I want Unix/Linux skills that work everywhere

Git Bash Foundation

• Time to first success: ~1 hour
• Learning curve: Steeper but rewarding
• Best for: Professional development, cross-platform work

Not Sure? Here’s What Most People Do

If you’re reading this and unsure:

Start with Command Prompt (CMD). It’s the gentlest introduction. You’ll be productive quickly and can always switch to PowerShell or Git Bash later. The skills transfer completely.

After completing CMD:

• Want more power? PowerShell is next
• Want Linux skills? Git Bash is next
• Want to stick with CMD? You have all the skills you need

FAQ

Q: Do I need to pick now and stick with it forever? A: No. Start with one, try another, switch between them. They’re tools. Use what works.

Q: Will my 3D printing skills work in all three? A: Yes. Once you understand the concepts (file organization, automation, piping), they apply everywhere.

Q: If I pick CMD, can I learn PowerShell later? A: Absolutely. Many learners do exactly this. CMD gets you productive; PowerShell adds power.

Q: Is Git Bash harder? A: Slightly, due to path syntax and Unix conventions. But not dramatically. If you take time with it, you’ll learn it.

Q: Which do professional 3D printing developers use? A: Mix of all three, but Git Bash/Linux is most common in cross-platform teams.

Ready to Begin?

Choose your path above and click to start. Remember:

• Each lesson includes practice exercises
• You can’t break anything
• Mistakes are learning opportunities
• Ask for help if stuck

Let’s get you comfortable with the command line!

Other Screen Readers

Dolphin SuperNova (commercial) and Windows Narrator (built-in) are also supported; the workflows and recommendations in this document apply to them. See https://yourdolphin.com/supernova/ and https://support.microsoft.com/narrator for vendor documentation.

Foundation of Command Line Tools — Complete Curriculum

Command-Line Fundamentals — Choose Your Path

Welcome! Before diving into 3D design with OpenSCAD, you’ll master command-line fundamentals. This page will help you understand what command-line interfaces are and choose the best path for you.

What is a Command-Line Interface (CLI)?

A command-line interface is a text-based way to control your computer by typing commands instead of clicking buttons. It’s like sending written instructions to your computer.

Why learn it?

• Speed: Text commands are often faster than clicking through menus
• Precision: Exact control over what your computer does
• Accessibility: Perfect for screen readers - text is naturally readable
• Automation: Repeat tasks automatically
• 3D Printing: Essential for batch processing models and integrating tools

Real-world example

Instead of:

1. Opening File Explorer (click)
2. Navigating folders (click, click, click)
3. Right-clicking a file (click)
4. Selecting “Copy” (click)
5. Navigating to destination (click, click)
6. Right-clicking (click)
7. Selecting “Paste” (click)

You type: cp myfile.txt backup/ and press Enter. Done.

Three Command-Line Options on Windows

Windows offers three ways to use the command line. All are accessible with screen readers. Here’s how they compare:

Option 1: Windows Command Prompt (CMD)

What it is: The original Windows command-line (1981-present)

Best for: Absolute beginners, maximum simplicity

Pros:

• Simple commands and syntax
• Minimal learning curve
• Easy to understand error messages
• Great for basic file operations
• Perfect entry point to command-line world

Cons:

• Limited advanced features
• Less powerful than alternatives
• No built-in piping (but available)
• Smaller ecosystem

Typical command:

copy myfile.txt backup\

Option 2: PowerShell

What it is: Microsoft’s modern, powerful shell (2006-present)

Best for: Intermediate users, advanced automation

Pros:

• Very powerful for scripting
• Modern syntax and features
• Excellent for 3D printing automation
• Professional workflows
• Large community

Cons:

• Steeper learning curve than CMD
• More complex syntax
• More “wordy” commands
• Overkill for simple tasks

Typical command:

Copy-Item -Path myfile.txt -Destination backup/

Option 3: Git Bash

What it is: A Unix/Linux shell on Windows (runs bash inside Git for Windows)

Best for: Programmers, users familiar with Linux, advanced users

Pros:

• Familiar if you know Linux/Unix
• Powerful piping and text processing
• Consistent with other platforms (macOS, Linux)
• Excellent for advanced workflows
• Industry-standard for developers

Cons:

• Requires Git installation
• Steeper learning curve
• Path syntax is different from native Windows
• Less integrated with Windows system tools
• May be “too much” for beginners

Typical command:

cp myfile.txt backup/

Command Comparison Table

Here’s how common tasks compare across the three options:

Feature Comparison Table

Quick Learner Profile Test

Answer these questions to find your best match:

Question 1: Experience Level

• A: I’ve never used a command line Easier paths better (CMD or PowerShell)
• B: I’ve used terminals before Any path works
• C: I use macOS or Linux Git Bash most natural

Question 2: What matters most?

• A: Simplicity and quick learning Choose CMD
• B: Power and advanced features Choose PowerShell
• C: Consistency across Windows/Mac/Linux Choose Git Bash

Question 3: Future goals

• A: Just need to manage files for 3D printing CMD is fine
• B: Advanced automation and scripting PowerShell recommended
• C: Professional development workflows Git Bash best

Question 4: Your main concern

• A: Don’t want steep learning curve CMD
• B: Want industry-standard skills Git Bash
• C: Want Microsoft’s modern tool PowerShell

Recommendation by Goal

Goal: “I want to learn the basics and get to 3D printing quickly”

Start with CMD (Command Prompt)

• Simplest syntax
• Fastest to get productive
• All core concepts transfer to others
• Can switch later if needed

Start CMD Foundation — jump to Part 2 ↓

Goal: “I want power and professional automation”

Start with PowerShell

• Microsoft’s modern, recommended tool
• Professional-grade capabilities
• Better for complex 3D printing workflows
• Skills are in-demand

Start PowerShell Foundation — jump to Part 1 ↓

Goal: “I want skills that work on Windows, Mac, and Linux”

Start with Git Bash

• Unix/bash skills transfer everywhere
• Great preparation for professional development
• Consistent across all platforms
• Growing standard in 3D printing tools

Start Git Bash Foundation — jump to Part 3 ↓

Can I Switch Paths Later?

Yes, absolutely! All three teach the same fundamental concepts:

• File navigation and organization
• Creating and managing files/folders
• Combining commands for powerful workflows
• Scripting and automation basics

Once you learn one, switching to another is quick. The concepts are identical; only the syntax changes.

Example: If you learn CMD first, then later want PowerShell’s power, you’ll find it easy. The command cd Documents works the same way in all three.

Important: All Are Equally Accessible

Screen readers work perfectly with all three

• Text-based by nature (perfect for NVDA, JAWS)
• No mouse required
• Output is naturally readable
• Keyboard-only workflows

Note

All three shells — CMD, PowerShell, and Git Bash — work perfectly with NVDA, JAWS, Dolphin SuperNova, and Windows Narrator. Don’t let accessibility concerns influence your choice.

Don’t let accessibility concerns influence your choice. All are fully accessible.

Getting Started: Your Decision

Take a moment and choose:

1. I want the simplest path

Command Prompt Foundation — jump to Part 2 ↓

• Time to first success: ~30 minutes
• Learning curve: Gentlest
• When to upgrade: Once you’re comfortable and want power

2. I want modern, powerful Windows tools

PowerShell Foundation — jump to Part 1 ↓

• Time to first success: ~45 minutes
• Learning curve: Moderate
• Best for: Professional automation, 3D printing workflows

3. I want Unix/Linux skills that work everywhere

Git Bash Foundation — jump to Part 3 ↓

• Time to first success: ~1 hour
• Learning curve: Steeper but rewarding
• Best for: Professional development, cross-platform work

Not Sure? Here’s What Most People Do

If you’re reading this and unsure:

Tip

Start with Command Prompt (CMD). It’s the gentlest introduction, and you’ll be productive quickly. You can always switch to PowerShell or Git Bash later — the concepts transfer completely.

After completing CMD:

• Want more power? PowerShell is next
• Want Linux skills? Git Bash is next
• Want to stick with CMD? You have all the skills you need

FAQ

Q: Do I need to pick now and stick with it forever? A: No. Start with one, try another, switch between them. They’re tools. Use what works.

Q: Will my 3D printing skills work in all three? A: Yes. Once you understand the concepts (file organization, automation, piping), they apply everywhere.

Q: If I pick CMD, can I learn PowerShell later? A: Absolutely. Many learners do exactly this. CMD gets you productive; PowerShell adds power.

Q: Is Git Bash harder? A: Slightly, due to path syntax and Unix conventions. But not dramatically. If you take time with it, you’ll learn it.

Q: Which do professional 3D printing developers use? A: Mix of all three, but Git Bash/Linux is most common in cross-platform teams.

Ready to Begin?

Choose your path above and click to start. Remember:

• Each lesson includes practice exercises

Tip

You can’t break your computer by typing a wrong command. The worst that happens is an error message. Mistakes are learning opportunities — just read the message and try again.

• You can’t break anything
• Mistakes are learning opportunities
• Ask for help if stuck

Let’s get you comfortable with the command line!

Other Screen Readers

Dolphin SuperNova (commercial) and Windows Narrator (built-in) are also supported; the workflows and recommendations in this document apply to them. See https://yourdolphin.com/supernova/ and https://support.microsoft.com/narrator for vendor documentation.

Last Updated: February 2026 Total Duration: ~30–45 hours per track (screen reader users) Target Users: Anyone using a screen reader — NVDA, JAWS, Dolphin SuperNova, Windows Narrator

This combined curriculum covers three command-line environments taught in parallel. Each section follows the same lesson structure (Pre → 0 → 1 → 2 → 3 → 4 → 5 → 6 → Unit Exam) with shell-specific syntax and examples.

Master Table of Contents

Part 1 — PowerShell

Part 2 — Windows Command Prompt (CMD)

Part 3 — Git Bash

Quick Jump — By Lesson Across All Three Shells

Part 1 — PowerShell

Last Updated: February 2026
Total Duration: 30–45 hours of instruction and practice (for screen reader users)
Target Users: Anyone using a screen reader (NVDA, JAWS, Dolphin SuperNova, Windows Narrator, or other)

This single file contains the complete PowerShell Foundation curriculum in reading order. All lessons, quizzes, extension problems, and the unit exam are included. No additional files are needed.

Table of Contents

Total: approximately 30–45 hours including practice exercises

How to Use This File

If you have never used a terminal before: read from the top in order. Do not skip lessons — each builds on the one before it.

If you have used a terminal but not with a screen reader: start with the Accessibility Guide, skim Lesson Pre, then continue from Lesson 0.

If you are experienced with both: jump directly to the lesson you need. Use the quiz at the end of each lesson to self-test before moving on.

Reference while working: the Accessibility Guide and Lesson 0 contain material you will return to throughout the curriculum. Keep a copy open or bookmark those sections.

Curriculum Rules (Read These First)

Rule 1 — Always know where you are.
Every session, first thing: pwd. If you don’t know your path, you’ll get lost.

Rule 2 — Check before you delete.
Before any rm command: ls -n to confirm what you’re about to remove.

Rule 3 — Use -n with ls.
Always ls -n — never bare ls. The -n flag gives one name per line, which screen readers can follow.

Rule 4 — When lost, redirect to a file.
If output is confusing: command > output.txt then notepad.exe output.txt. This always works.

Rule 5 — Save everything you create.
Keep all practice files in a dedicated learning folder: mkdir ~/PS_Learning.

Screen Reader Accessibility Guide

Target Users: NVDA, JAWS, and other screen reader users
Last Updated: 2026

This guide supports the PowerShell Foundation curriculum and helps screen reader users navigate and work efficiently with PowerShell on Windows.

Table of Contents

1. Getting Started with Screen Readers
2. NVDA-Specific Tips
3. JAWS-Specific Tips
4. General Terminal Accessibility
5. Working with Long Output
6. Keyboard Shortcuts Reference
7. Troubleshooting

Getting Started with Screen Readers

Which Screen Reader Should I Use?

NVDA is free and often recommended for new users; JAWS is a powerful commercial option. Also consider Dolphin SuperNova and Windows Narrator:

• Dolphin SuperNova: commercial speech, braille and magnification (check vendor docs for keyboard mappings).
• Windows Narrator: built into Windows and useful for quick access without installing third-party software.

Before You Start

1. Start your screen reader before opening PowerShell.
2. Open PowerShell and listen for the window title and prompt.
3. If silent, press Alt+Tab to find the window.

What is PowerShell?

PowerShell is the modern Windows shell and scripting environment. Common commands include Get-ChildItem, Get-Content, and Out-File. PowerShell provides richer objects and piping than CMD.

NVDA-Specific Tips

NVDA is available from https://www.nvaccess.org/

Dolphin SuperNova

Dolphin SuperNova: https://yourdolphin.com/supernova/ — commercial option providing speech and magnification; consult vendor guides for features and commands.

Windows Narrator

Windows Narrator: https://support.microsoft.com/narrator — built-in Narrator has a different set of commands; it can be enabled via Windows Settings > Accessibility.

Key Commands for PowerShell

Example: Reading Long Output

If Get-ChildItem produces many lines, redirect to a file and open it in Notepad:

Get-ChildItem -Name > list.txt
notepad list.txt

-Name prints one item per line (screen reader friendly).

JAWS-Specific Tips

JAWS is available from https://www.freedomscientific.com/

Key Commands for PowerShell

Example: Reading Long Output

1. Redirect: Get-ChildItem -Name > list.txt
2. Open Notepad: notepad list.txt
3. Use Insert+Ctrl+Down to read full contents.

General Terminal Accessibility

Understanding the PowerShell Layout

PowerShell shows a title bar, content area, and a prompt that looks like:

PS C:\Users\YourName>

Navigation Sequence

1. Screen reader announces the title
2. Then it announces the prompt line
3. Anything above prompt is prior output

Working with Long Output

Solution 1: Redirect to a File

Get-ChildItem -Name > list.txt
notepad list.txt

Solution 2: Use Pagination

Get-Content largefile.txt | more

Solution 3: Filter Output

Get-ChildItem -Name | Where-Object { $_ -like "*.scad" }

Solution 4: Count Before Displaying

(Get-ChildItem -Name).Count

Keyboard Shortcuts Reference

Troubleshooting

Problem: “I Can’t Hear the Output”

1. Redirect to file and open in Notepad.
2. Use End to jump to the end of text.

Problem: “Tab Completion Isn’t Working”

1. Type some characters before Tab.

Problem: “Command Not Found”

1. Use Get-Command programname to check availability.

Pro Tips

1. Use Get-ChildItem -Name for one-per-line listings.
2. Use Out-File -FilePath list.txt to capture output with encoding options.

Recommended Workflow

1. Set-Location (or cd) to the project folder
2. Get-ChildItem -Name to list files
3. Redirect large output to files and open in Notepad

Additional Resources

• NVDA Documentation: https://www.nvaccess.org/documentation/
• JAWS Documentation: https://www.freedomscientific.com/support/
• PowerShell Documentation: https://docs.microsoft.com/powershell
• NVDA Documentation: https://www.nvaccess.org/documentation/
• JAWS Documentation: https://www.freedomscientific.com/support/
• Dolphin SuperNova: https://yourdolphin.com/supernova/
• Windows Narrator: https://support.microsoft.com/narrator

Lesson Pre: Your First Terminal

Duration: 1.5-2 hours (for screen reader users)
Prerequisites: None - this is the starting point
Accessibility Note: This lesson is designed specifically for screen reader users (NVDA, JAWS)

What is a Terminal?

A terminal (also called a command line or shell) is a text-based interface where you type commands instead of clicking buttons. Think of it like sending written instructions to your computer instead of pointing and clicking.

Why learn this?

• Faster and more precise work (especially for 3D printing scripts and automation)
• Essential for programming and using tools like OpenSCAD
• Accessibility: Many command line tools work perfectly with screen readers
• Scripting: Automate repetitive tasks

Opening PowerShell for the First Time

3DMake: Your First Real-World Goal

3DMake (github.com/tdeck/3dmake) is a free, accessibility-first command-line tool for designing and 3D-printing models entirely from the terminal — no mouse required. Every PowerShell skill in this curriculum directly supports a real 3DMake workflow.

Here is the end goal — one command that builds your OpenSCAD model, slices it, and sends it to the printer:

# Navigate to your project folder
cd ~/Documents/3d_projects/my_cube

# Build, slice, and print in a single command
3dm build slice print

Keep this goal in mind as you work through each lesson.

Opening PowerShell for the First Time

On Windows

Method 1: Search (Easiest)

1. Press the Windows key alone
2. You should hear “Search”
3. Type: PowerShell
4. You’ll hear search results appear
5. Press Enter to open the first result (Windows PowerShell)
6. PowerShell will open in a new window

Method 2: Using the Start Menu

1. Press Windows key + X (opens the Quick Link menu)
2. Look for “Windows PowerShell” or “Terminal”
3. Press Enter

Method 3: From File Explorer

1. Open File Explorer
2. Navigate to any folder
3. In the menu bar, select “File” -> “Open Windows PowerShell here”
4. PowerShell opens in that folder location

First Connection: Understanding the Prompt

When PowerShell opens, your screen reader will announce the window title and then the prompt. The prompt is where you type commands.

What you’ll hear:

PS C:\Users\YourName>

What this means:

• PS = “PowerShell” indicator
• C:\Users\YourName = Your current location (the “path”)
• > = The prompt is ready for your input

Important

Your cursor is blinking right after the >. This is where you type.

Your First Commands (Screen Reader Edition)

Command 1: “Where Am I?” - pwd

What it does: Tells you your current location

Type this:

pwd

Press Enter

What you’ll hear: Your screen reader will announce the current path, something like:

C:\Users\YourName

Understanding paths:

• Paths show your location in the file system (like a mailing address)
• Windows paths use backslashes: C:\Users\YourName\Documents
• Think of it like folders inside folders: C:\ (main drive) -> Users -> YourName -> Documents

Command 2: “What’s Here?” - ls -n

What it does: Lists all files and folders in your current location. The -n flag makes it screen-reader friendly (names only, one per line)

Type this:

ls -n

Press Enter

What you’ll hear: Your screen reader will announce each file and folder name, one per line:

Desktop
Documents
Downloads
Music
Pictures
...

Why -n?

• Without -n, PowerShell shows files in columns (hard to read with a screen reader)
• With -n, each file/folder is on its own line (perfect for screen readers)

Command 3: “Go There” - cd Documents

What it does: Changes your location (navigates to a folder)

Type this:

cd Documents

Press Enter

What you’ll hear: The prompt changes to show your new location. You might hear something like:

PS C:\Users\YourName\Documents>

Practice navigation:

1. Run pwd to confirm you’re in Documents
2. Run ls -n to see what files are in Documents
3. Try going back: cd .. (the .. means “go up one level”)
4. Run pwd again to confirm
5. Go back to Documents: cd Documents

Reading Screen Reader Output (Critical Skills)

Dealing with Long Lists

When you run ls -n in a folder with many files, the list might be very long. Your screen reader might announce 50+ items rapidly.

Solution 1: Save to a File

ls -n > list.txt
notepad.exe list.txt

This saves the list to a file and opens it in Notepad where you can read it more slowly.

Solution 2: Search Within the Output

ls -n | findstr "search-term"

Example: If you’re looking for files containing “scad”, type:

ls -n | findstr "scad"

Navigating Tab Completion

One of the most powerful screen reader tricks is Tab completion:

How it works:

1. Type the first few letters of a folder or file name
2. Press Tab
3. PowerShell automatically completes the rest

Example:

1. You’re in C:\Users\YourName>
2. Type: cd Doc
3. Press Tab
4. PowerShell auto-completes it to: cd Documents
5. Press Enter to go there

With a screen reader:

1. As you type Doc, your screen reader announces each letter
2. When you press Tab, PowerShell types the rest and your screen reader announces the full command
3. This is much faster than typing the whole thing

Creating and Editing Files

Create a Simple File

Type this:

echo "Hello, PowerShell!" > hello.txt

What this does:

• echo sends text to the screen (or file)
• "Hello, PowerShell!" is the text
• > redirects it to a file called hello.txt

Read the File Back

Type this:

cat hello.txt

What you’ll hear: Your screen reader announces:

Hello, PowerShell!

Open and Edit the File

Type this:

notepad.exe hello.txt

This opens the file in Notepad where you can edit it with your screen reader.

Essential Keyboard Shortcuts

These work in PowerShell and are crucial for screen reader users:

Important

Ctrl+C stops any running command immediately. If a command seems frozen or is producing endless output, press Ctrl+C to regain control of the prompt.

| Ctrl+C | Stops a running command | | Ctrl+L | Clears the screen | | Enter | Runs the command |

Screen reader tip: These all work perfectly with your screen reader. Try them!

Screen Reader-Specific Tips

NVDA Users

1. Reading Command Output:

   • Use NVDA+Home to read the current line
   • Use NVDA+Down Arrow to read to the end of the screen
   • Use NVDA+Page Down to read the next page

2. Reviewing Text:

   • Use NVDA+Shift+Page Up to review text above

JAWS Users

1. Reading Output:

   • Use Insert+Down Arrow to read line-by-line
   • Use Insert+Page Down to read by page
   • Use Insert+End to jump to the end of text

2. Reading All Text:

   • Use Insert+Down Arrow repeatedly
   • Or use Insert+Ctrl+Down to read to the end

Common Issue: “I Can’t Hear the Output”

Problem: You run a command but don’t hear the output

Solutions:

1. Make sure your cursor is at the prompt (try pressing End or Ctrl+End)
2. Use Up Arrow to go back to your previous command and review it
3. Try redirecting to a file: command > output.txt then open the file
4. In NVDA: Try pressing NVDA+F7 to open the Review Mode viewer

Practice Exercises

Complete these in order. Take your time with each one:

Exercise 1: Basic Navigation

1. Open PowerShell
2. Run pwd and note your location
3. Run ls -n and listen to what’s there
4. Try cd Documents or another folder
5. Run pwd to confirm your new location
6. Run ls -n in this new location

Goal: You should be comfortable knowing where you are and what’s around you

Exercise 2: Using Tab Completion

1. In your home directory, type cd D (just the letter D)
2. Press Tab
3. PowerShell should auto-complete to a folder starting with D
4. Repeat with other folder names
5. Try typing a longer name: cd Down and Tab to Downloads

Goal: Tab completion should feel natural

Exercise 3: Creating and Viewing Files

1. Create a file: echo "Test content" > test.txt
2. View it: cat test.txt
3. Create another: echo "Line 2" > another.txt
4. List both: ls -n

Goal: You understand create, view, and list operations

Exercise 4: Going Up Levels

1. Navigate into several folders: cd Documents, then cd folder1, etc.
2. From deep inside, use cd .. multiple times to go back up
3. After each cd .., run pwd to confirm your location

Goal: You understand relative navigation with ..

Exercise 5: Redirecting Output

1. Create a list: ls -n > directory_list.txt
2. Open it: notepad.exe directory_list.txt
3. Read it with your screen reader
4. Close Notepad
5. Verify the file exists: ls -n | findstr "directory"

Goal: You can save long outputs to files for easier reading

Checkpoint Questions

After completing this lesson, you should be able to answer:

1. What does pwd do?
2. What does ls -n do?
3. Why do we use -n with ls?
4. What path are you in right now?
5. How do you navigate to a new folder?
6. How do you go up one level?
7. What’s the Tab key for?
8. What does echo "text" > file.txt do?
9. How do you read a file back?
10. How do you stop a command that’s running?

You should be able to answer all 10 with confidence before moving to Lesson 0.

Common Questions

Q: Do I need to use PowerShell? Can I use Command Prompt (cmd.exe)? A: PowerShell is more powerful and works better with modern tools. We recommend PowerShell, but Command Prompt basics are similar.

Tip

If your screen reader isn’t announcing terminal output, use command > file.txt to save output to a file, then open it with notepad.exe file.txt for reliable reading. This trick works with all four screen readers throughout the curriculum.

Q: Why is my screen reader not reading the output? A: This is common. Use command > file.txt to save output to a file, then open it with Notepad for reliable reading.

Q: What if I type something wrong? A: Just press Enter and you’ll see an error message. Type the correct command on the next line. No harm done!

Q: How do I get help with a command? A: Type Get-Help command-name (we’ll cover this in Lesson 0)

Q: Can I make PowerShell more accessible? A: Yes! We’ll cover customization in Lesson 5.

Next Steps

Once you’re comfortable with these basics:

• Move to Lesson 0: Getting Started for deeper path understanding
• Then continue through Lessons 1–5 for full terminal mastery

Resources

• Microsoft PowerShell Docs: https://docs.microsoft.com/powershell/
• NVDA Screen Reader: https://www.nvaccess.org/
• JAWS Screen Reader: https://www.freedomscientific.com/products/software/jaws/
• Windows Terminal Accessibility: https://docs.microsoft.com/windows/terminal/

Troubleshooting

Still stuck? The checkpoint questions and exercises are your best teacher. Work through them multiple times until comfortable.

Other Screen Readers

Dolphin SuperNova (commercial) and Windows Narrator (built-in) are also supported; the workflows and recommendations in this document apply to them. See https://yourdolphin.com/supernova/ and https://support.microsoft.com/narrator for vendor documentation.

Lesson 0: Getting Started — Layout, Paths, and the Shell

Estimated time: 20-30 minutes

Learning Objectives

• Launch PowerShell and locate the prompt
• Understand path notation and shortcuts (~, ./, ../)
• Use tab completion to navigate quickly

Materials

• Computer with PowerShell
• Editor (Notepad/VS Code)

Step-by-step Tasks

1. Open PowerShell and note the prompt (it includes the current path).
2. Run pwd and say or note the printed path.
3. Use ls -n to list names in your home directory.
4. Practice cd Documents, cd ../ and cd ~ until comfortable.
5. Try tab-completion: type cd ~/D and press Tab.

Checkpoints

• Confirm you can state your current path and move to Documents.

Quiz - Lesson PS.0

3DMake Quick-Start: Your First Real Project

You now know enough PowerShell to set up a real 3DMake project. Do this now — it is the fastest path to a printed object.

Step 1 — Download and run the 3DMake setup wizard:

# Go to your Downloads folder (where you extracted 3dmake_windows.zip)
cd ~/Downloads/3dmake

# Run the guided setup (answer the questions about your printer)
./3dm setup

Step 2 — Create your first project:

# Create a folder for all your 3D projects
mkdir ~/Documents/3d_projects

# Create your first project folder and initialize it
mkdir ~/Documents/3d_projects/my_cube
cd ~/Documents/3d_projects/my_cube
3dm new

Step 3 — Confirm the project structure:

# You should see three items: src, build, and 3dmake.toml
ls -n

You just used mkdir, cd, and ls -n on a real project. You are ready to print.

Checkpoints

• Confirm you can state your current path and move to Documents.

Quiz - Lesson PS.0

1. What is a path?
2. What does ~ mean?
3. How do you autocomplete a path?
4. How do you go up one directory?
5. What command lists only names (ls flag)?
6. True or False: On Windows, PowerShell uses backslashes (\) in paths, but forward slashes (/) are also accepted.
7. Explain the difference between an absolute path and a relative path.
8. If you are in C:\Users\YourName\Documents and you type cd ../, where do you end up?
9. What happens when you press Tab while typing a folder name in PowerShell?
10. Describe a practical reason why understanding paths is important for a 3D printing workflow.
11. What does ./ mean in a path, and when would you use it?
12. If a folder path contains spaces (e.g., Program Files), how do you navigate to it with cd?
13. Explain what the prompt PS C:\Users\YourName> tells you about your current state.
14. How would you navigate to your home directory from any location using a single command?
15. What is the advantage of using relative paths (like ../) versus absolute paths in automation scripts?

Extension Problems

1. Create a nested folder and practice cd into it by typing partial names and using Tab.
2. Use ls -n -af to list only files in a folder.
3. Save pwd output to a file and open it in Notepad.
4. Try cd into a folder whose name contains spaces; observe how quotes are handled.
5. Create a short note file and open it from PowerShell.
6. Build a folder structure that mirrors your project organization; navigate to each level and document the path.
7. Create a script that prints your current path and the total number of files in it; run it from different locations.
8. Investigate the special paths (e.g., $HOME, $PSScriptRoot); write down what each contains and when you’d use them.
9. Compare absolute vs. relative paths by navigating to the same folder using each method; explain which is easier for automation.
10. Create a PowerShell function that changes to a frequently-used folder and lists its contents in one command; test it from different starting locations.
11. Navigate to three different locations and at each one note the prompt, the path from pwd, and verify you understand what each shows.
12. Create a complex folder tree (at least 5 levels deep) and navigate it using only relative paths; verify your location at each step.
13. Document all shortcuts you know (~, ./, ../, $HOME) and demonstrate each one works as expected.
14. Write a guide for a peer on how to understand the PowerShell prompt and path notation without using GUI file explorer.
15. Create a troubleshooting flowchart: if someone says “I don’t know where I am,” what commands do you give them to find out?

References

• Microsoft. (2024). PowerShell scripting overview and documentation. https://learn.microsoft.com/powershell/scripting/overview
• Microsoft. (2024). Filesystem navigation in PowerShell. https://learn.microsoft.com/powershell/scripting/learn/shell/navigate-the-filesystem
• Microsoft. (2024). Accessibility features in PowerShell ISE. https://learn.microsoft.com/powershell/scripting/windows-powershell/ise/accessibility-in-windows-powershell-ise

Helpful Resources

• PowerShell Basics - Microsoft Learn
• Filesystem Navigation Guide
• Understanding Path Notation
• Tab Completion Reference
• Accessibility in PowerShell ISE

Lesson 1: Navigation — Moving Around Your File System

Duration: 1 class period
Prerequisite: Lesson 0 (Getting Started)

Learning Objectives By the end of this lesson, you will be able to:

• Use pwd to print your current location
• Use cd to move between directories
• Use ls (and its flags) to list files and folders
• Use wildcards * and ? to filter listings
• Navigate relative vs. absolute paths
• Search for files by name and extension

Materials

• PowerShell
• Text editor (Notepad or VS Code)

Commands Covered in This Lesson

pwd - Where Am I?

Type pwd and press Enter. PowerShell prints the full path to your current location.

pwd
# Output: C:\Users\YourName

When to use: Always run this if you’re unsure of your current location.

cd - Changing Directories

cd stands for “change directory.”

# Go to Documents
cd Documents
# Go up one level to parent directory
cd ..
# Go to home directory
cd ~
# Go to a specific path
cd C:\Users\YourName\Documents\3D_Projects

ls - Listing Files and Folders

Use ls -n for screen reader compatibility.

# List all files and folders (names only)
ls -n
# List only files (no folders)
ls -n -af
# List only folders (no files)
ls -n -ad

Wildcards - Finding Files by Pattern

Wildcards help you find files without typing the full name.

* (asterisk) matches any number of characters:

# List all .scad files
ls -n *.scad
# List all files starting with "part"
ls -n part*
# List all files ending with "_final"
ls -n *_final*

? (question mark) matches exactly one character:

# Find files like model1.scad, model2.scad (but not model12.scad)
ls -n model?.scad

Step-by-step Practice

3DMake in Practice: Navigating a Project

Navigation commands are exactly what you need to explore and manage 3DMake projects:

# Go to your project root
cd ~/Documents/3d_projects/my_cube

# See the project layout: src/, build/, 3dmake.toml
ls -n

# Enter the source folder where your .scad model files live
cd src
ls -n

# Open the main model in your text editor
3dm edit-model

# Go back to project root, then check the build output
cd ..
cd build
ls -n *.stl        # list any STL files already built

# Return to project root
cd ..

# Use wildcards to find all projects with "cube" in the name
ls -n ~/Documents/3d_projects/*cube*

Tab completion makes navigation fast: type cd ~/Doc and press Tab.

Step-by-step Practice

1. Run pwd and confirm your location
2. Move to Documents: cd Documents
3. Confirm you moved: pwd
4. List files and folders: ls -n
5. List only files: ls -n -af
6. Go back up: cd ..
7. Search for files: ls -n *.txt

Checkpoints

After this lesson, you should be able to:

• Navigate to any folder using cd
• Confirm your location with pwd
• List files and folders with ls -n
• Use wildcards to find files by pattern
• Move between absolute and relative paths confidently

Quiz - Lesson PS.1

1. What does pwd show?
2. How do you list directories only with ls?
3. What wildcard matches any number of characters?
4. How do you list files with the .scad extension?
5. Give an example of an absolute path and a relative path.
6. True or False: The * wildcard matches exactly one character.
7. Explain the difference between ls -n and ls -n -ad.
8. Write a command that would list all .txt files in your Documents folder using a wildcard.
9. How would you search for files containing “part” in their name across multiple files?
10. Describe a practical scenario where using wildcards saves time in a 3D printing workflow.
11. What happens when you use ls -n part?.scad versus ls -n part*.scad?
12. How would you navigate to a folder whose name contains both spaces and special characters?
13. If you’re in /Documents/Projects/3D and you want to go to /Documents/Resources, what command would you use?
14. Write a command sequence that navigates to the Downloads folder, lists only files, then returns to home.
15. Explain the purpose of using ls -n -af specifically in a screen reader context.

Extension Problems

1. Write a one-line script that lists .scad files and saves to scad_list.txt.
2. Use ls -n ~/Documents | more to page through long listings.
3. Combine ls with Select-String to search for a filename pattern.
4. Create a shortcut alias in the session for a long path and test it.
5. Practice tab-completion in a directory with many similarly named files.
6. Build a PowerShell script that recursively lists all .scad and .stl files in a directory tree; save the results to a file.
7. Compare the output of ls, Get-ChildItem, and gci to understand PowerShell aliasing; document what each command does.
8. Create a filtering command that displays only files modified in the last 7 days; test it on your documents folder.
9. Write a non-visual guide to PowerShell navigation; include descriptions of common patterns and how to verify directory contents audibly.
10. Develop a navigation workflow for a typical 3D printing project: move between CAD, slicing, and print-log folders efficiently; document the commands.
11. Create a complex wildcard search: find all files in a folder and subfolders that match multiple patterns (e.g., *_v1.* OR *_final.*).
12. Build a script that navigates through a folder tree, counts files at each level, and reports the structure.
13. Document the output differences between ls -n, ls -n -af, ls -n -ad, and Get-ChildItem; explain when to use each.
14. Create a navigation “cheat sheet” as a PowerShell script that prints common paths and how to navigate to them.
15. Design a project folder structure on your computer, document each path, then create a script that validates all folders exist.

References

• Microsoft. (2024). Get-ChildItem cmdlet reference. https://learn.microsoft.com/powershell/module/microsoft.powershell.management/get-childitem
• Microsoft. (2024). PowerShell wildcards and filtering. https://learn.microsoft.com/powershell/scripting/learn/shell/using-wildcards
• Microsoft. (2024). Navigation best practices in PowerShell. https://learn.microsoft.com/powershell/scripting/learn/shell/navigate-the-filesystem

Helpful Resources

• Get-ChildItem Cmdlet Reference
• PowerShell Wildcards and Filtering
• Navigation Best Practices
• Relative and Absolute Paths
• Screen Reader Tips for PowerShell

Lesson 2: File and Folder Manipulation

Estimated time: 30-45 minutes

Learning Objectives

• Create, copy, move, and delete files and folders from PowerShell
• Use ni, mkdir, cp, mv, rm, and rmdir safely
• Understand when operations are permanent and how to confirm results

Materials

• PowerShell
• Small practice folder for exercises

Step-by-step Tasks

1. Create a practice directory: mkdir ~/Documents/PS_Practice and cd into it.
2. Create two files: ni file1.txt and ni file2.txt.
3. Copy file1.txt to file1_backup.txt with cp and confirm with ls -n.
4. Rename file2.txt to notes.txt using mv and confirm.
5. Delete file1.txt with rm and verify the backup remains.

Checkpoints

• After step 3 you should see both the original and the backup file.

3DMake in Practice: Organizing Your Projects

File management commands are essential for 3DMake project organization:

# Create a new project from scratch
mkdir ~/Documents/3d_projects/bottle_cap
cd ~/Documents/3d_projects/bottle_cap
3dm new

# Back up a working project before making big changes
cd ~/Documents/3d_projects
cp -r bottle_cap bottle_cap_backup

# Rename the main model file to something more specific
cd bottle_cap/src
mv main.scad bottle_cap.scad

# List only .scad files to confirm the rename
ls -n *.scad

# Delete a draft STL you no longer need
rm ~/Documents/3d_projects/bottle_cap/build/draft.stl

# Now build the renamed model (using the -m flag to specify the name)
cd ~/Documents/3d_projects/bottle_cap
3dm build -m bottle_cap

# See the fresh output in the build folder
ls -n build/

Checkpoints

• After step 3 you should see both the original and the backup file.

Quiz - Lesson PS.2

1. How do you create an empty file from PowerShell?
2. What command copies a file?
3. How do you rename a file?
4. What does rm -r do?
5. Why is rm potentially dangerous?
6. True or False: cp requires the -r flag to copy both files and folders.
7. Explain the difference between rm and rmdir.
8. If you delete a file with rm, can you recover it from PowerShell?
9. Write a command that would copy an entire folder and all its contents to a new location.
10. Describe a practical safety check you would perform before running rm -r on a folder.

Caution

By default, cp silently overwrites an existing file at the destination with no warning. Use cp -i (interactive) to get a confirmation prompt before overwriting, especially when working with important files.

11. What happens if you cp a file to a destination where a file with the same name already exists? How would you handle this safely?
12. Compare mv old_name.txt new_name.txt vs mv old_name.txt ~/Documents/new_name.txt. What is the key difference?
13. Design a workflow to safely delete 50 files matching the pattern *.bak from a folder containing 500 files. What commands and verifications would you use?
14. Explain how you could back up all .scad files from a project folder into a timestamped backup folder in one command.
15. When organizing a 3D printing project, you need to move completed designs to an archive folder and delete failed prototypes. How would you structure this as a safe, auditable process?

Extension Problems

1. Create a folder tree and copy it to a new location with cp -r.
2. Write a one-line command that creates three files named a b c and lists them.
3. Move a file into a new folder and confirm the move.
4. Use wildcards to delete files matching a pattern in a safe test folder.
5. Export a listing of the practice folder to practice_listing.txt.
6. Create a backup script that copies all .scad files from your project folder to a backup folder with timestamp naming.
7. Build a safe deletion workflow: list files matching a pattern, verify count, then delete with confirmation; document the steps.
8. Write a PowerShell script that organizes files by extension into subfolders; test it on a sample folder tree.
9. Create a file operation audit trail: log all copy, move, and delete operations to a text file for review.
10. Develop a project template generator: a script that creates a standard folder structure for a new 3D printing project with essential subfolders.
11. Implement a file conflict handler: write a script that handles cases where cp would overwrite an existing file by renaming the existing file with a timestamp before copying.
12. Create a batch rename operation: use a script to rename all files in a folder from old_prefix_* to new_prefix_*; test with actual files and verify the results.
13. Build a folder comparison tool: list all files in two folders and identify which files exist in one but not the other; output to a report.
14. Write a destructive operation validator: before executing rm -r, create a script that lists exactly what will be deleted, shows file counts by type, and requires explicit user confirmation to proceed.
15. Design a complete project lifecycle workflow: create folders for active projects, completed designs, and archive; include move operations between folders, backup steps, and verification that all files arrive intact.

References

• Microsoft. (2024). New-Item cmdlet reference. https://learn.microsoft.com/powershell/module/microsoft.powershell.management/new-item
• Microsoft. (2024). Copy-Item and Move-Item cmdlets. https://learn.microsoft.com/powershell/module/microsoft.powershell.management/copy-item
• Microsoft. (2024). File system operations guide. https://learn.microsoft.com/powershell/scripting/learn/shell/manipulating-items

Helpful Resources

• New-Item Cmdlet Reference
• Copy-Item and Move-Item
• Remove-Item Cmdlet Reference
• File System Operations Guide
• Safe Deletion Practices

Lesson 3: Input, Output, and Piping

Duration: 1 class period Prerequisite: Lesson 2 (File and Folder Manipulation)

Learning Objectives

By the end of this lesson, you will be able to:

• Use echo to print text to the screen
• Use cat to read file contents
• Use > to redirect output into a file
• Use | (pipe) to send one command’s output to another
• Copy output to the clipboard with clip
• Open files with a text editor from the command line

Commands Covered

echo - Printing Text

echo prints text to the screen. It is useful for testing, for writing text into files, and for understanding how piping works.

echo "Hello, World"
echo "This is a test"

cat - Reading Files

cat prints the contents of a file to the screen.

# Read a text file
cat ~/Documents/notes.txt
# Read an OpenSCAD file
cat ~/Documents/OpenSCAD_Projects/project0.scad

With a long file, use cat filename | more to read it page by page (press Space to advance, Q to quit).

> - Redirecting Output to a File

The > symbol redirects output from the screen into a file instead.

# Create a file with a single line
echo "Author: Your Name" > header.txt
# Confirm the file was created and has content
cat header.txt

Warning

> overwrites the file if it already exists. Use >> to append instead:

echo "Date: 2025" >> header.txt
echo "Project: Floor Marker" >> header.txt
cat header.txt

| - Piping

The pipe symbol | sends the output of one command to the input of the next. This lets you chain commands together.

# List files and send the list to clip (copies to clipboard)
ls -n | clip
## 3DMake in Practice: Capturing Build Output

Piping and redirection are essential for working with 3DMake's output accessibly:

```powershell
# Build and save the full log to a file so you can read it in Notepad
3dm build > build_log.txt
notepad.exe build_log.txt

# Build and slice, keeping only lines with errors or warnings
3dm build slice 2>&1 | Select-String -Pattern "error|warning" -CaseSensitive:$false

# List all STL files produced so far
ls -n build/ | findstr ".stl"

# Get a list of available printer profiles and save for reference
3dm list-profiles > profiles.txt
notepad.exe profiles.txt

# Get a list of material overlays (PLA, PETG, supports, etc.)
3dm list-overlays > overlays.txt
notepad.exe overlays.txt

# Get an AI description of your model and save it
3dm info > model_description.txt
notepad.exe model_description.txt

# List files and send the list to clip (copies to clipboard)
ls -n | clip
# Now paste with Ctrl + V anywhere

# Search within a file's contents using Select-String (like grep)
cat project0.scad | Select-String "cube"

clip - Copying to Clipboard

clip takes whatever is piped to it and puts it on the Windows clipboard.

# Copy your current directory path to the clipboard
pwd | clip
# Copy a file listing to clipboard
ls -n | clip
# Copy the contents of a file to clipboard
cat notes.txt | clip

After any of these, press Ctrl + V in any application to paste.

Opening Files in Notepad

# Open a file in Notepad
notepad.exe ~/Documents/notes.txt
# Open a .scad file
notepad.exe ~/Documents/OpenSCAD_Projects/project0.scad
# Create a new file and open it
notepad new_notes.txt

Step-by-step Tasks

1. Create practice.txt with three lines using echo and >/>>.
2. Read the file with cat practice.txt.
3. Pipe the file into Select-String to search for a word.
4. Copy the file contents to clipboard with cat practice.txt | clip.
5. Redirect ls -n into list.txt and open it in Notepad. Checkpoints

• After step 3 you should be able to find a keyword using piping.

Quiz - Lesson PS.3

1. What is the difference between > and >>?
2. What does the pipe | do?
3. How do you copy output to the clipboard?
4. How would you page through long output?
5. How do you suppress output to nowhere?
6. True or False: The pipe operator | connects the output of one command to the input of another.
7. Explain why redirecting output to a file is useful for screen reader users.
8. Write a command that would search for the word “sphere” in all .scad files in a directory.
9. How would you count the number of lines in a file using PowerShell piping?
10. Describe a practical scenario in 3D printing where you would pipe or redirect command output.
11. What would be the difference in output between echo "test" > file.txt (run twice) vs echo "test" >> file.txt (run twice)? Show the expected file contents.
12. Design a three-step piping chain: read a file, filter for specific content, and save the results; explain what each pipe does.
13. You have a 500-line .scad file and need to find all instances of sphere() and count them. Write the command.
14. Explain how clip is particularly valuable for screen reader users when working with file paths or long output strings.
15. Describe how you would use pipes and redirection to create a timestamped backup report of all .stl files in a 3D printing project folder.

Extension Problems

1. Use piping to count lines in a file (hint: Select-String -Pattern '.' | Measure-Object).
2. Save a long ls -n output and search it with Select-String.
3. Chain multiple pipes to filter and then save results.
4. Practice copying different command outputs to clipboard and pasting.
5. Create a small script that generates a report (counts of files by extension).
6. Build a data processing pipeline: read a CSV file, filter rows, and export results; document each step.
7. Write a script that pipes directory listing to Count occurrences of each file extension; create a summary report.
8. Create a log analysis command: read a log file, filter for errors, and save matching lines to a separate error log.
9. Design a piping workflow for 3D printing file management: find .stl files, extract their sizes, and generate a report.
10. Develop a reusable piping function library: create functions for common filtering, sorting, and reporting patterns; test each function with different inputs.
11. Build a complex filter pipeline: read a .scad file, extract lines containing specific geometry commands, count each type, and output a summary to both screen and file.
12. Create an interactive piping tool: build a script that accepts user input for a search term, pipes through multiple filters, and displays paginated results.
13. Develop a performance analysis tool: use piping to combine file listing, metadata extraction, and statistical reporting; export results to a dated report file.
14. Implement a comprehensive error-handling pipeline: read output, catch errors, log them separately, and generate a summary of successes vs failures.
15. Design and execute a real-world project backup workflow: use piping to verify file integrity, count files by type, generate a backup manifest, and create audit logs-all in one integrated command pipeline.

References

• Microsoft. (2024). Out-File cmdlet for redirection. https://learn.microsoft.com/en-us/powershell/module/microsoft.powershell.utility/out-file
• Microsoft. (2024). Select-String piping reference. https://learn.microsoft.com/en-us/powershell/module/microsoft.powershell.utility/select-string
• Microsoft. (2024). PowerShell pipeline concepts. https://learn.microsoft.com/en-us/powershell/scripting/learn/deep-dives/everything-about-pipeline

Helpful Resources

• Using Out-File for Redirection
• Piping and Select-String
• Get-Content Cmdlet Reference
• Measure-Object for Counting
• PowerShell Pipeline Concept

Lesson 4: Environment Variables, PATH, and Aliases

Estimated time: 30-45 minutes

Learning Objectives

• Read environment variables with $env:VARNAME
• Inspect and verify programs in the PATH
• Create temporary aliases and understand making them persistent via the profile

Materials

• PowerShell (with rights to open profile if desired)

Step-by-step Tasks

1. Show your username and home path with echo $env:USERNAME and echo $env:USERPROFILE.
2. Inspect echo $env:PATH and identify whether openscad or code would be found.
3. Run Get-Command openscad and note the result.
4. Create a temporary alias: Set-Alias -Name preview -Value openscad and test preview myfile.scad.
5. Open your profile (notepad.exe $PROFILE) and add the alias line to make it persistent (advanced).