diff --git a/CblGdbExt/CblGdb/README.md b/CblGdbExt/CblGdb/README.md
index 48e2345d865e3b9c5bc423185af5d0948fb468a8..3ab7fc7b1e19d65110700e24404fbdcbbb0a1e43 100644
--- a/CblGdbExt/CblGdb/README.md
+++ b/CblGdbExt/CblGdb/README.md
@@ -2,7 +2,7 @@
 
 This extension provides source-level debugging of COBOL programs compiled with the GnuCOBOL COBOL compiler.
 
-August 6, 2020
+September 24, 2020
 Bob Dubner
 support@cobolworx.com
 
@@ -10,21 +10,22 @@ support@cobolworx.com
 
 COBOL source code is compiled with the GnuCOBOL compiler.  Debugging information and a gdb extension are added to the executable by the COBOLworx cbl-gdb routines.  The resulting executable can be debugged directly by the [GNU Project Debugger `gdb`](https://www.gnu.org/software/gdb/).
 
-That executable can also be debugged on the source-code level with this extension, which provides a VSC Debug Adapter that is aware of the COBOLworx extensions to gdb that makes source-level debugging possible.
+That executable can also be debugged on the source-code level with this extension, which provides a VSC Debug Adapter that is aware of the COBOLworx extensions to gdb that make source-level debugging possible.
 
-## Prerequisites - GnuCOBOL
+## Prerequisites: GnuCOBOL
 
-In order to debug a COBOL program, it must first be compiled with an appropriate version of the GnuCOBOL compiler.  The compiler must be the 3.1 version or later and built with [GCC](https://www.gnu.org/software/gcc/).
+In order to debug a COBOL program, it must first be compiled with the GnuCOBOL compiler.  The compiler must be the 3.1 version.  The package must be at least the 3.1-rc2 version; rc1 and earlier versions will not work.
 
 GnuCOBOL installation packages for Ubuntu, RedHat, and Windows can be found at [COBOLworx downloads](https://cobolworx.com/pages/downloads.html).  
 
-Those who prefer to build from source can downloaded the latest version from [here](https://alpha.gnu.org/gnu/gnucobol/).  The build sequence starts with `./configure`.
-As an alternative you may build from developer source code, which is available in the [GnuCOBOL SVN repository](https://svn.code.sf.net/p/gnucobol/code/branches/gnucobol-3.x).  The build sequence starts with `./autogen.sh`, for details see its `HACKING` file.
+Those who prefer to build the GnuCOBOL compiler from source can downloaded the latest version from [here](https://alpha.gnu.org/gnu/gnucobol/).  The build sequence starts with `./configure`.
+
+As an alternative you may build from developer source code, which is available in the [GnuCOBOL SVN repository](https://svn.code.sf.net/p/gnucobol/code/branches/gnucobol-3.x).  The build sequence starts with `./autogen.sh`; for details see its `HACKING` file.
 
 
 More information can be found at the [GnuCOBOL project site](https://www.gnu.org/software/gnucobol/).
 
-## Prerequisites - COBOLworx cbl-gdb debugging extensions
+## Prerequisites: COBOLworx cbl-gdb debugging extensions
 
 As part of the compilation process, the cbl-gdb extensions need to be applied before the executable can be debugged using gdb and VSC.
 
@@ -32,11 +33,11 @@ Download and install the appropriate `COBOLworx GnuCOBOL Debugging Extensions pa
 
 ## Installation
 
-If you didn't install this extension from [Open VSX Registry](https://open-vsx.org/?search=COBOLworx) or the [Microsoft Visual Studio Code Marketplace](https://marketplace.visualstudio.com/vscode), then you probably downloaded a file named cbl-gdb-3.2.1.vsix, which is a Visual Studio Code extension package.  You have a couple of options for loading the extension into VS code:
+If you didn't install this extension from [Open VSX Registry](https://open-vsx.org/?search=COBOLworx) or the [Microsoft Visual Studio Code Marketplace](https://marketplace.visualstudio.com/vscode), then you probably downloaded a file named cbl-gdb-4.1.1.vsix, which is a Visual Studio Code extension package.  You have a couple of options for loading the extension into VS code:
 
 - From inside Visual Studio Code, use the Command Palette `(Ctrl+Shift+P)` to find "Extensions: Load extension from VSIX..."  Select that, and point it at the .VSIX file.
 
-- From the command line, execute `code --install-extension cbl-gdb-3.2.1.vsix`
+- From the command line, execute `code --install-extension cbl-gdb-4.1.1.vsix`
 
 ## Additional extensions
 
@@ -74,9 +75,10 @@ Create a text file CTEST.CBL
 ```        
 ### Verify that GnuCOBOL is the right version:
 
-The shell command `cobc --version | head -n 1` should return  
+The shell command `cobc --version | head -n 1` should return one of
 
-    cobc (GnuCOBOL) 3.1-dev.0
+    cobc (GnuCOBOL) 3.1-dev.202009023
+    cobc (GnuCOBOL) 3.1-rc2.0
 
 or greater.
 
@@ -112,11 +114,11 @@ The immediate output from GDB should look like this:
 ```
 $ gdb -q CTEST
 Reading symbols from CTEST...
-registering CPrint (Usage is "print  <COBOL identifier>") [Version 2.9]
+registering CPrint (Usage is "print  <COBOL identifier>") [Version 4.1]
 registering CWatch (Usage is "cwatch <COBOL identifier>")
 ```
 
-*It is important that the two lines indicating CPRINT and CWATCH have been registered appear here.  If they are missing, then the cbl-gdb package wasn't completely installed.*
+*It is important that the two lines indicating PRINT and CWATCH have been registered appear here.  If they are missing, then the cbl-gdb package wasn't completely installed.*
 
 Entering the following sequence of commands: `l, b 7, r, n, n, n, n, n, n, n` should produce this output:
 
@@ -170,7 +172,7 @@ three
 
 ### Putting it all together
 
-At this point, Visual Studio Code has been installed, and the VSC extension for the COBOLworx Debugging Extensions has been installed into VSC.  GnuCOBOL 3.1-dev (or higher) has been installed and tested.  The COBOLworx cbl-gdb debugging extensions have also been installed and tested.
+At this point, Visual Studio Code has been installed, and the VSC extension for the COBOLworx Debugging Extensions has been installed into VSC.  GnuCOBOL 3.1-rc2 (or higher) has been installed and tested.  The COBOLworx cbl-gdb debugging extensions have also been installed and tested.
 
 We are now ready to demonstrate source-level debugging of COBOL with Visual Studio Code.
 
@@ -194,7 +196,7 @@ A `select environment` dropdown list will appear.  Select `COBOLworx cbl-gdb Gnu
 
 In the editor view, select the file `CTEST.CBL`.
 
-Set a breakpoint on Line 7 `000007 DISPLAY "Simple".`
+Set a breakpoint on Line 7 `000007 DISPLAY "Simple".` by pressing the F9 key or clicking in the gutter to the left of the line of code.
 
 *If you can't set a breakpoint (shown as a red dot to the left of the editor's line number) see the note up above about setting the Debug option* `Allow Breakpoints Anywhere`.
 
@@ -230,7 +232,11 @@ You are now ready to start working with more complex COBOL programs.
 
 ## Advanced topic: Attaching to existing processes
 
-If you are in the business of attaching to existing processes, you'll need a different launch.json file.  You'll need an `attach` configuration and an `inputs` section:
+If you are in the business of attaching to existing processes, we offer you a couple of choices.
+
+If you used the default environment provided by this extension, the Debugging view has a dropdown selection in the `Run` selector: `Attach to COBOL process with cbl-gdb debugger`.  When that is selected, a too-small data entry windows will appear with the text `Enter the PID of the process`. Replace that with the PID of your process, and the debugger will attach to it.
+
+If you prefer a bit more control over what's going on, you can create your own "attach" configuration in the launch.json file.  It might look like this:
 
 ```
     "configurations": [
@@ -257,14 +263,20 @@ When you execute `Debug > Start Debugging (F5)` and choose `Attach to COBOL debu
 
 Take special note of the `"solibs"` variable.  As described here it gets set from a global environment variable.  It doesn't have to be set that way, but if the application involves dynamically-loaded shared libraries, the `"solibs"` variable somehow has to be set to a colon-separated list of folders that include the location of your libraries (assuming you have any, of course).  If `"solibs"` isn't set, then the instance of gdb launched by Visual Studio Code won't be able to find the symbols for those libraries.
 
-## Note: Automatic display of variables
+## Automatic display of variables
 
 COBOL, particularly older code, sometimes has modules with hundreds, even thousands or tens of thousands of variables.  To avoid uselessly filling the VSC Variables pane with thousands of variables, the COBOLworx extension attempts to analyze the code near the breakpoint to show you just the variables that seem relevant.
 
-That means that sometimes you might need to manually ask for a variable.
+It does this through the `print ?` command.  `print ?` examines a range of lines around where the program is currently stopped.  That value currently defaults to +/- six lines.
+
+The bottom of the DEBUG CONSOLE allows you to enter commands directly to GDB.  You can use that command line to change the range of lines that are examined.  `p/r` will respond with the current setting.  `p/r N` will set the range to +/- N.  `p/r 0` is valid; it sets the range to just the line you are stopped on.  `p/r -1` sets the range to be the entire program.
+
+## Command line variable display.
+
+The cbl-gdb debugger tries to be helpful. If you type `p RECORD-COUNT` into the DEBUG CONSOLE command line, it'll look for a variable of that name. Failing that, it'll look for variables that contain "RECORD-COUNT" as part of their names.
 
-The COBOLworx extension, like gdb itself, has a command-line interface.  You can use it by typing into the "expression evaluator" at the bottom of the DEBUG CONSOLE window.  You can type in the command `p RECORD-COUNT` and the extension will show you the contents of that variable.  `p REC` will show you all variables that have `REC` as part of their name.
+This means you can use shortcuts: `p REC` will show you all variables containing "REC".  This will, of course, give you "RECORD-COUNT".  It can save a lot of time.
 
-`p/h` generates a concise list of the COBOLworx `p` commands.
+`p/h` generates a concise list of the COBOLworx `print` commands.
 
-In particular, `p/r N` sets the width of the search for things that look like variables to +/- N lines around the breakpoint.  `p/r 0` sets it to just the one line.  `p/r 12` means that a range of 25 lines are checked.  The "best" setting may well depend on the coding style of the program being debugged, so experimentation may be in order.
\ No newline at end of file
+More information on using the cbl-gdb debugger can be found at the [COBOLworx knowledge base](https://cobolworx.com/pages/cbl-gdb-kb.html)
diff --git a/CblGdbExt/CblGdb/package.json b/CblGdbExt/CblGdb/package.json
index 71a289e2e27c03faad9407862f3781de44ecba81..8749f206b92dba77477517f3b475a22603ddc4f2 100644
--- a/CblGdbExt/CblGdb/package.json
+++ b/CblGdbExt/CblGdb/package.json
@@ -16,9 +16,11 @@
 	},
 	"main": "./out/src/frontend/extension",
 	"activationEvents": [
-		"onCommand:code-debug.examineMemoryLocation",
-		"onCommand:code-debug.getFileNameNoExt",
-		"onCommand:code-debug.getFileBasenameNoExt"
+		"onCommand:cbl-gdb.examineMemoryLocation",
+		"onCommand:cbl-gdb.getFileNameNoExt",
+		"onCommand:cbl-gdb.getFileBasenameNoExt",
+		"onCommand:cbl-gdb.getAttachPID"
+
 	],
 	"categories": [
 		"Debuggers"
@@ -30,8 +32,8 @@
 	"contributes": {
 		"commands": [
 			{
-				"command": "code-debug.examineMemoryLocation",
-				"title": "Code-Debug: Examine memory location"
+				"command": "cbl-gdb.examineMemoryLocation",
+				"title": "cbl-gdb: Examine memory location"
 			}
 		],
 		"debuggers": [
@@ -41,8 +43,9 @@
 				"runtime": "node",
 				"label": "COBOLworx cbl-gdb GnuCOBOL debugging",
 				"variables": {
-					"FileBasenameNoExt": "code-debug.getFileBasenameNoExt",
-					"FileNameNoExt": "code-debug.getFileNameNoExt"
+					"FileBasenameNoExt": "cbl-gdb.getFileBasenameNoExt",
+					"FileNameNoExt": "cbl-gdb.getFileNameNoExt",
+					"getAttachPID": "cbl-gdb.getAttachPID"
 				},
 				"configurationAttributes": {
 					"launch": {
@@ -322,7 +325,16 @@
 						"program": "${workspaceFolder}/${fileBasenameNoExtension}",
 						"cwd": "${workspaceFolder}",
 						"arguments": ""
+					},
+					{
+						"name": "Attach to COBOL process with cbl-gdb debugger",
+						"type": "cbl-gdb",
+						"request": "attach",
+						"cwd":"${workspaceFolder}",
+						"solibs":"${env:PRIM_LIBRARY_PATH}",
+						"process_id": "${command:getAttachPID}"
 					}
+
 				]
 			}
 		]
diff --git a/CblGdbExt/CblGdb/src/frontend/extension.ts b/CblGdbExt/CblGdb/src/frontend/extension.ts
index 4f3cf99a8d136823feffaccb2b7c5bf0ccbcc265..a7727e53fc3d3318b7cadfb74cfd253a93e1f87b 100644
--- a/CblGdbExt/CblGdb/src/frontend/extension.ts
+++ b/CblGdbExt/CblGdb/src/frontend/extension.ts
@@ -25,6 +25,13 @@ export function activate(context: vscode.ExtensionContext) {
 		const ext = path.extname(fileName);
 		return fileName.substr(0, fileName.length - ext.length);
 	}));
+	context.subscriptions.push(vscode.commands.registerCommand("cbl-gdb.getAttachPID", () => {
+		return vscode.window.showInputBox({
+		  placeHolder: 'Enter the PID to attach to',
+		  value: 'Enter the PID of the process'
+		});
+	  }
+	));
 }
 
 const memoryLocationRegex = /^0x[0-9a-f]+$/;
diff --git a/CblGdbExt/samples/infinite_loop/.gitignore b/CblGdbExt/samples/infinite_loop/.gitignore
new file mode 100644
index 0000000000000000000000000000000000000000..67ffbc0176598dd4e0001249bcbfc73b8127c8d2
--- /dev/null
+++ b/CblGdbExt/samples/infinite_loop/.gitignore
@@ -0,0 +1,3 @@
+m
+rtest.exe
+rtest
diff --git a/CblGdbExt/samples/infinite_loop/.vscode/launch.json b/CblGdbExt/samples/infinite_loop/.vscode/launch.json
new file mode 100644
index 0000000000000000000000000000000000000000..5c144af36a8cab3d369ce2d0195a3b8660bd7660
--- /dev/null
+++ b/CblGdbExt/samples/infinite_loop/.vscode/launch.json
@@ -0,0 +1,25 @@
+{
+    // Use IntelliSense to learn about possible attributes.
+    // Hover to view descriptions of existing attributes.
+    // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+    "version": "0.2.0",
+    "configurations": [
+        {
+            "name": "cobc build and debug",
+            "type": "cbl-gdb",
+            "request": "launch",
+            "preLaunchTask": "make",
+            "program": "${workspaceFolder}/${fileBasenameNoExtension}",
+            "cwd": "${workspaceFolder}",
+            "arguments": ""
+        },
+        {
+            "name": "Attach to cobc process with cbl-gdb debugger",
+            "type": "cbl-gdb",
+            "request": "attach",
+            "cwd": "${workspaceFolder}",
+            "solibs": "${env:PRIM_LIBRARY_PATH}",
+            "process_id": "${command:getAttachPID}"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/CblGdbExt/samples/infinite_loop/Makefile b/CblGdbExt/samples/infinite_loop/Makefile
new file mode 100644
index 0000000000000000000000000000000000000000..b9ccb53afac233ff464150667b236ed084f1e1b4
--- /dev/null
+++ b/CblGdbExt/samples/infinite_loop/Makefile
@@ -0,0 +1,3 @@
+
+all : 
+	cobcd -x infloop.cbl
diff --git a/CblGdbExt/samples/infinite_loop/infloop b/CblGdbExt/samples/infinite_loop/infloop
new file mode 100755
index 0000000000000000000000000000000000000000..ec0b0860124067324f0cd1d84426e1cefe6f6e08
Binary files /dev/null and b/CblGdbExt/samples/infinite_loop/infloop differ
diff --git a/CblGdbExt/samples/infinite_loop/infloop.cbl b/CblGdbExt/samples/infinite_loop/infloop.cbl
new file mode 100644
index 0000000000000000000000000000000000000000..6d0e9d52f5add175e2c3d94deef9e7088ea2e364
--- /dev/null
+++ b/CblGdbExt/samples/infinite_loop/infloop.cbl
@@ -0,0 +1,15 @@
+       ID DIVISION.
+       PROGRAM-ID. infloop.
+       DATA DIVISION.
+       WORKING-STORAGE SECTION.
+        77 counter PIC 9(9)      VALUE ZERO.
+        77 state_of_hell PIC 9   VALUE 0.
+            88 hell-freezes-over VALUE 1.
+       PROCEDURE DIVISION.
+       PERFORM UNTIL hell-freezes-over
+      *> Just runs forever.  This is a target for testing
+      *> the ability to attach to a running process
+            DISPLAY counter
+            ADD 1 to counter
+            END-PERFORM.
+       END PROGRAM infloop.
diff --git a/CblGdbExt/samples/optfde01/.gitignore b/CblGdbExt/samples/optfde01/.gitignore
index 980229a016a18cf0c088a835634fa63cce9f7d94..3ad933ae2d52e931864c0016eb71da138a748889 100644
--- a/CblGdbExt/samples/optfde01/.gitignore
+++ b/CblGdbExt/samples/optfde01/.gitignore
@@ -1,5 +1,6 @@
 dd_output
 optfde01
+optfde01.so
 optfde01.c
 optfde01.c.h
 optfde01.c.l.h
diff --git a/CblGdbExt/samples/optfde01/.vscode/launch.json b/CblGdbExt/samples/optfde01/.vscode/launch.json
index b2098c34e099d3092b60a4d5a5789cca80f3f7f1..65f0f0bf755184e018b9a4c4d2c9abd1070680d8 100755
--- a/CblGdbExt/samples/optfde01/.vscode/launch.json
+++ b/CblGdbExt/samples/optfde01/.vscode/launch.json
@@ -12,7 +12,6 @@
             "preLaunchTask": "make",
             "program": "${workspaceRoot}/optfde01",
             "cwd": "${workspaceFolder}",
-            "arguments": "",
             "debugServer": 4711
         },
         {
@@ -24,6 +23,5 @@
             "cwd": "${workspaceFolder}",
             "arguments": ""
         }
-        
     ]
 }
\ No newline at end of file