<PERSON> made a good point in that phrasing the question correctly is difficult and important. Your comment indicated that you wanted the answer to the only "interesting" way of formulating the question: "how well" can a program approximate the halting problem? I co-authored a paper on exactly this, and some related questions. It was published at ICALP 2015, then the long version was published in LMCS. A summary is below.
First, the notion of a "proportion of programs" is heavily dependent on how you enumerate all possible programs. Common programming languages are "sparse": if you generate a random string of bytes, it likely won't be a valid C program, for example. So most programs are "trivial", and once you choose the convention (e.g. nonsensical programs halt), then you can approximate the halting problem by saying "all programs halt", and be right almost 100% of the time. Of course, that's completely uninteresting. The right way to avoid this is to require the enumeration $A_1, A_2, ...$ to be optimal: for any other enumeration of programs $B_1, B_2, ...$ there exists a constant $K$ such that every program $B_i$ is equivalent to some program $A_j$ with $j<i+K$. 904
These "optimal programming languages" aren't hard to build, and they're important building blocks in the theory around <PERSON> complexity.
OK, so now that the subtlety about programming language optimality is out of the way, are we done with the preliminaries? Not really: we also have to define what it mean for a decision procedure to approximate the halting problem. Is it allowed to never return for some outputs, like in <PERSON>'s answer? Is it allowed to make mistakes? Let $P$ be the decision procedure: $P(i)$ tries to guess whether $A_i$ halts. Let's define its success rate at step $n$:
$$ s_P(n)=\frac{\left{i<n \mid P(i) \text{ halts and is correct} \right}}{n} $$
Further, are we interested in the "guaranteed" rate of success for sufficiently large $N$? Or are we interested in "how muchthe $\liminf$ or the $\limsup$ of $s_P(n)$? (See here for definitions.)
The outcome changes depending on the answers to the previous questions. But here is the tl;dr, with pointers to the theorems in the long version of our paper.
* For any procedure P, there will be an $\epsilon>0$ and a $N$ such that for all $n>N$, $s_P(n)<1-\epsilon$. This holds even if you allow $P$ both to never halt sometimes, and to make errors (Theorem 3.1.a.).
* Now, can we make the $\epsilon$ independent of the procedure $P$? Kind of: there exists a $\alpha$ such that for any procedure $P$, $\liminf_n s_P(n)<1-\alpha$. Put another way, the rate of error is going to be above some fixed constant, infinitely many times. Again, this holds even with a $P$ that can both never return or be wrong (Theorem 3.1.b).
* OK, but can we make the $\limsup$ as high as we want? Yes! For every $\epsilon>0$, there exists a procedure $P$ such that $\limsup_n s_P(n)>1-\epsilon$ (Theorem 3.1.c).
* Except! What if we force the procedure $P$ to be error-free, like in <PERSON>'s answer? Can we still make the $\limsup$ as high as we want? The answer is a shocking it depends on the optimal programming language. This is, by the way, extremely surprising: almost every other result in algorithmic complexity does not depend on the choice of the language (Theorem 3.1.d).
The negative results (the first two bullet points) also hold if $P$ is allowed to be probabilistic in a "naive" sense (Theorem 3.3.), by letting the procedure have access to random bits. You can also formalize the notion of "solving the halting problem probabilistically" in a more complex way, that makes a little more sense in this context, in which case you get slightly (but not very) different results (Theorems 5.1, 5.3 and 5.5). 603